gls_multi_view.h

Go to the documentation of this file.

/*! \file
  \brief  The disti::GlsMultiView class.

  \par Copyright Information

  Copyright (c) 2015 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 _GLS_MultiView_H
#define _GLS_MultiView_H

#include "group.h"
#include "gls_eyepoint.h"
#include "display_types.h"

#define LIB_BASE_NAME "gls_multi_view"
#include "gls_auto_lib.h"
#undef LIB_BASE_NAME

//////////////////// Provides support for creating DLLs ////////////////////////
#if (defined(GLSGEN_EXPORT_GlsMultiView) || \
     defined(GLSGEN_IMPORT_GlsMultiView) || \
     defined(GLS_EXPORT_GENERATED) || \
     defined(GLS_IMPORT_GENERATED)) \
     && defined(_MSC_VER) 
#  if defined(GLSGEN_EXPORT_GlsMultiView) || defined(GLS_EXPORT_GENERATED)
#    define GLSGEN_GlsMultiView_EXPORT  __declspec(dllexport)
#  else
#    define GLSGEN_GlsMultiView_EXPORT  __declspec(dllimport)
#  endif
#else
#  define GLSGEN_GlsMultiView_EXPORT
#endif
///////////////////////////////////////////////////////////////////////////////

namespace disti
{

    // SetValue enumerations
enum {
    GLS_GLSMULTIVIEW_FIRST_VALUE = GLS_LAST_INITIALIZER+1,
    GLS_GLSMULTIVIEW_VIEW_DATA,
    GLS_GLSMULTIVIEW_VIEW_DRAWING_STATE
 };
class ComponentLightMgr;

/** Runtime implementation of GlsMultiView */
class GlsMultiView : public Group
{
    friend class GlsMultiViewEditor;
public:   
    typedef Group _BaseClass;

    /** Create a new GlsMultiView.
      * \param generateInstance  Whether or not to generate an instance name
      * for this inputdevice */
    GLSGEN_GlsMultiView_EXPORT GlsMultiView(int generateInstance=FALSE);

    GLSGEN_GlsMultiView_EXPORT GlsMultiView( const GlsMultiView& that, const bool generateNames );

    /** GlsMultiView deconstructor */
    virtual GLSGEN_GlsMultiView_EXPORT ~GlsMultiView();

    static GLSGEN_GlsMultiView_EXPORT DisplayObject* CreateInstance();

    virtual GLSGEN_GlsMultiView_EXPORT void SetAvailableAttributes(unsigned int value);
    virtual GLSGEN_GlsMultiView_EXPORT DisplayObject *CloneObject(bool generateNames = FALSE);
    virtual GLSGEN_GlsMultiView_EXPORT void PreDraw( const OpenGLMatrices& parentMatrices,Culler &culler );
    virtual GLSGEN_GlsMultiView_EXPORT void Draw(void);
    virtual GLSGEN_GlsMultiView_EXPORT void CopyProperties(DisplayObject *src);
#ifndef GLES
    virtual GLSGEN_GlsMultiView_EXPORT InterfaceListType* GetCppInterfaceDescription(InterfaceListType* addToThisList= NULL );
    virtual GLSGEN_GlsMultiView_EXPORT void GetCppInterfaceDescriptionFree(InterfaceListType* array);
#endif
    virtual GLSGEN_GlsMultiView_EXPORT DisplayObject *Pick3D(const Vector& winLoc, 
                                            const Vector& logicalCoords,
                                            float scale, 
                                            const Vector& directionVector, 
                                            Vector &collisionWinLoc, /*Returned*/
                                            const OpenGLMatrices& drawnMatrices);
    virtual GLSGEN_GlsMultiView_EXPORT DisplayObject* handle(DisplayEvent *ev);
    virtual GLSGEN_GlsMultiView_EXPORT DistiAttributeBase& Resource(const char *name);
    virtual GLSGEN_GlsMultiView_EXPORT void GetResources(std::ostream& outstr, GlsResourceFilter* filter= NULL);
    virtual GLSGEN_GlsMultiView_EXPORT void SetValue(int spec,va_list &args);

    //////////////////////////////////////////////////
    // Object specific operations
    //////////////////////////////////////////////////

    enum {
        CLEAR_BG_OFF  = 0,
        CLEAR_BG_DEPTH_AND_COLOR = 1,
        CLEAR_BG_DEPTH = 2,
        CLEAR_BG_COLOR = 3
    } ClearBackgroundEnum;

    class ViewData : virtual public AttributeChangedNotifier
    {
        friend class GlsMultiView;
        friend class GlsMultiViewEditor;
    private:
        float _bottom;
        float _left;
        float _top;
        float _right;
        bool _absolutePixels;
        GlsEyePoint* _eyepoint;
        std::string _desiredEyePoint;
        int _clearBackground;
        bool _pickGeometry;
        bool _visible;
        bool _pickable;

        DistiAttribDict* _attribDict;
        GlsMatrixType* _modelMatrix;
        GlsMatrixType* _projMatrix;
        int* _viewPort;
        bool _cullerVal;

    public:
        GLSGEN_GlsMultiView_EXPORT ViewData();
        GLSGEN_GlsMultiView_EXPORT ViewData(const ViewData&);
        GLSGEN_GlsMultiView_EXPORT ~ViewData();

        /** Assignment operator */
        GLSGEN_GlsMultiView_EXPORT const ViewData& operator=(const ViewData&);
        GLSGEN_GlsMultiView_EXPORT void CopyBaseData(const ViewData& other);

        inline DistiAttribDict& Attributes() { return *_attribDict; };
        
        virtual GLSGEN_GlsMultiView_EXPORT void NotifyAttributeChanged( const AttributeName& name );

        /** Sets the Screen Rectangle
          * The screen rect is specified in 0.0-1.0 as a ratio of the available viewport
          * e.g. 0.0, 0.0, 1.0, 1.0 uses the full screen */
        GLSGEN_GlsMultiView_EXPORT void SetScreenRect(float bottom, float left, float top, float right);
        /** Gets the current screen rectangle
          */
        GLSGEN_GlsMultiView_EXPORT void GetScreenRect(float* bottom, float* left, float* top, float* right);

        /** Set the bottom value */
        GLSGEN_GlsMultiView_EXPORT void Bottom(const float &);
        /** Gets the bottom value */
        GLSGEN_GlsMultiView_EXPORT float Bottom();
        /** Sets the left value */
        GLSGEN_GlsMultiView_EXPORT void Left(const float &);
        /** Gets the left value */
        GLSGEN_GlsMultiView_EXPORT float Left();
        /** Sets the top value */
        GLSGEN_GlsMultiView_EXPORT void Top(const float &);
        /** Gets the top value */
        GLSGEN_GlsMultiView_EXPORT float Top();
        /** Sets the right value */
        GLSGEN_GlsMultiView_EXPORT void Right(const float &);
        /** Gets the right value */
        GLSGEN_GlsMultiView_EXPORT float Right();
        /** Set the absolute pixels flag 
          * When true, the Left-Right-Top-Bottom values are interpreted
          * as pixel coordinates, otherwise they are percentage of screen space*/
        GLSGEN_GlsMultiView_EXPORT void AbsolutePixels(const bool &);
        /** Get the absolute pixels flag 
          * When true, the Left-Right-Top-Bottom values are interpreted
          * as pixel coordinates, otherwise they are percentage of screen space*/
        GLSGEN_GlsMultiView_EXPORT bool AbsolutePixels();

        /** Sets the eyepoint to view from
          * When NULL, the parent view is used */
        GLSGEN_GlsMultiView_EXPORT void EyePoint(GlsEyePoint*);
        private: 
        // For public access, use GetEyePoint().  It requires an object pointer.
        GLSGEN_GlsMultiView_EXPORT GlsEyePoint* EyePoint();
        public:

        /** Sets the clear background mode
          * 0 == Don't Clear; 1 == Clear both; 2 == Depth only; 3 == Color only 
          * \sa ClearBackgroundEnum
          */
        GLSGEN_GlsMultiView_EXPORT void ClearBackground(const int &);
        /** Gets the clear background mode */
        GLSGEN_GlsMultiView_EXPORT int ClearBackground();

        /** Sets the pick geometry bool
          * When true, the geometry will be traversed with Pick3D in this
          * view. 
          */
        GLSGEN_GlsMultiView_EXPORT void PickGeometry(const bool &);
        /** Gets the pick geometry bool
          */
        GLSGEN_GlsMultiView_EXPORT bool PickGeometry();

        /** Sets the visibility of this view 
          */
        GLSGEN_GlsMultiView_EXPORT void Visible(const bool &);
        /** Gets the visibility of this view
          */
        GLSGEN_GlsMultiView_EXPORT bool Visible();

        /** Sets if this view is pickable
          * If true, and PickGeometry() is false, the view
          * area will be picked
          */
        GLSGEN_GlsMultiView_EXPORT void Pickable(const bool &);
        /** Gets the pickability of this view
          */
        GLSGEN_GlsMultiView_EXPORT bool Pickable();

        // Methods for property "EyePointName"
        GLSGEN_GlsMultiView_EXPORT void DesiredEyePoint(const GlsPropString&);
        GLSGEN_GlsMultiView_EXPORT GlsPropString DesiredEyePoint();

        /** Finds the eyepoint or returns a previously found one.  
          * It will be based on the _desiredEyePoint.
          */
        GLSGEN_GlsMultiView_EXPORT GlsEyePoint* GetEyePoint(const DisplayObject* heirarchiedObject);

        /** Forces eyepoint reload */
        GLSGEN_GlsMultiView_EXPORT void ForceEyePointReload();

        GLSGEN_GlsMultiView_EXPORT OpenGLMatrices SavedMatrices();
        
    };

    typedef DynamicArray<ViewData, false> ViewDataArray;

    typedef enum {
        GEOMETRY_ONLY = 0,
        GEOMETRY_AND_VIEWS,
        VIEWS_ONLY
    } ViewDrawStateEnum;

    /** Set the ViewDrawingState 
      */
    GLSGEN_GlsMultiView_EXPORT void ViewDrawingState(ViewDrawStateEnum);
    /** Get the ViewDrawingState 
      */
    GLSGEN_GlsMultiView_EXPORT ViewDrawStateEnum ViewDrawingState();

    /** Returns the number of views 
      * \return The view count 
      */
    GLSGEN_GlsMultiView_EXPORT unsigned int ViewCount();

    /** Returns a reference to the specified View object
      * Creates it (and all views with a lower id) if it doesn't exist
      */
    GLSGEN_GlsMultiView_EXPORT ViewData& View(unsigned int viewNumber);

    /** Return a reference to the array containing the Views
      */
    GLSGEN_GlsMultiView_EXPORT ViewDataArray& ViewArray();

    /** Return the integer id of the last view that was picked or 
      * -1 if no view has been picked yet or if the GlsMultiview 
      * was picked because it is set to PICK_ALWAYS.
      */
    GLSGEN_GlsMultiView_EXPORT int LastViewPicked();

    /** Set the value for _emitViewDrawEvents
      * When true, an object event is emitted at the start and
      * end the draw of each view.
      * VIEW_DRAW_BEGIN and VIEW_DRAW_END
      * The data of the event is the view index.
      *
      * These events are currently EXPERIMENTAL and may be removed or
      * changed in a future release.  They are not accessable from the 
      * plugin GUI for this reason.
      */
    GLSGEN_GlsMultiView_EXPORT void EmitViewDrawEvents(const bool&);
    /** Get the value for _emitViewDrawEvents
      */
    GLSGEN_GlsMultiView_EXPORT bool EmitViewDrawEvents();

    // GlsMultiView utility functions
    void DrawView(unsigned int viewNumber, ViewData* view);

protected:
    void CalculateViewMatrices( const OpenGLMatrices& parentMatrices, Culler &culler, GlsMultiView::ViewData* view) const;
    bool PreDrawGeometryForView(int viewNumber, ViewData* view);
    void ReapplyGlobalLightsForView(ViewData* view);
    
#ifdef GLES
    /** Set a single attribute from the GLO file.
     * \param data The attribute to set and its associated data.
     */
    virtual void SetFromGloData(GlsGloFileAttribute &data);
#endif

    ViewDrawStateEnum _viewDrawingState;
    ViewDataArray _viewArray;
    ViewData _mainViewData;
    int _lastViewPicked;
    int _lastViewPredraw; // The number of the last view predraw or -1 if predraw used parent's view

    bool _showHighlights; // Used by the editor to turn on and off highlights
    int _highlightView; // Used by the editor to highlight a specific view.  -1 is none.

    bool _emitViewDrawEvents;

    ComponentLightMgr* _multiViewLightMgr; // Our very own light manager.
    bool _childLightsAffectGlobal; // Calculated internally based on if geometry is drawn.

    GlsMatrixType _savedProjectionMatrix; // Stores the projection matrix from PreDraw for restoring after DrawView

private:
    void DummySetInt(const int&) {} // Used for making a read only property
    GlsMultiView& operator=( const GlsMultiView& ) DISTI_SPECIAL_MEM_FUN_DELETE;
    GlsMultiView( const GlsMultiView& ) DISTI_SPECIAL_MEM_FUN_DELETE;

};

///////////////////////////////////////////////////////////////////////////////
//
// DistiAttributeViewDataArray Class
//            
///////////////////////////////////////////////////////////////////////////////

class DistiAttributeViewDataArray : public DistiAttributeBase
{
    GlsMultiView::ViewDataArray &_array;
public:
    DistiAttributeViewDataArray(CallbackMethodCallerBase* caller ,AttributeName name, GlsMultiView::ViewDataArray &array) :
        DistiAttributeBase(caller,name,false),
        _array(array)
    {
    }

    DistiAttributeBase& operator=(const DistiAttributeBase& oldClass)
    {
        const DistiAttributeViewDataArray* ptr;
        if( (ptr = dynamic_cast<const DistiAttributeViewDataArray*>(&oldClass)) )
        {
            // Copy array contents directly
            _array = _array;
            CallCallback();
        }
        else
        {
            // Copy by string value
            return DistiAttributeBase::operator=(oldClass);
        }
        return *this;
    }

    std::istream& ReadValue(std::istream& instr) 
    {
        // Scan through the token including the ':'
        std::string buf;

        // read through opening brace
        instr.ignore(1024,'{');

        // Clear the array before reading
        _array.ClearList();

        while (DistiAttribDict::ScanToken(instr, buf))
        {
            if (buf.length())
            {
                int index;
                index = atoi(buf.c_str());

                // Eat the space between the : and the data
                instr.get();
                instr.ignore(1024,'{');

                // This eats the closing brace
                _array[index].Attributes().Read(instr);
            }
        }
        CallCallback();

        return instr;
    }

    std::ostream& WriteValue(std::ostream& outstr) 
    {
        outstr << "\n" << DistiAttribDict::SpacingString()<<"{" << "\n";
        DistiAttribDict::SpacingInc();
        
        for (unsigned int i=0; i < _array.Count(); i++)
        {
            outstr <<DistiAttribDict::SpacingString()<< i <<":\n";
            outstr <<DistiAttribDict::SpacingString()<<"{\n";
            DistiAttribDict::SpacingInc();

            _array[i].Attributes().Write(outstr);

            DistiAttribDict::SpacingDec();
            outstr <<DistiAttribDict::SpacingString()<<"}\n";
        }
        DistiAttribDict::SpacingDec();
        outstr <<DistiAttribDict::SpacingString()<<"}";
        return outstr;
    }
};

} // namespace disti

#endif