GUI_ViewState.h

Go to the documentation of this file.

/*
 * PROPRIETARY INFORMATION.  This software is proprietary to
 * Side Effects Software Inc., and is not to be reproduced,
 * transmitted, or disclosed in any way without written permission.
 *
 * NAME:        GUI_ViewState.h (Geometry Render Library, C++)
 *
 * COMMENTS:
 *              This class basically envelopes a DisplayOption and
 *              a ViewParameter. So it holds all the information
 *              that is relevant to viewing.
 *
 */

#ifndef __GUI_ViewState__
#define __GUI_ViewState__

#include "GUI_API.h"
#include "GUI_DisplayOption.h"
#include "GUI_RenderCommon.h"
#include "GUI_ViewParameter.h"
#include <RE/RE_RenderContext.h>
#include <UT/UT_Matrix3.h>
#include <UT/UT_Matrix4.h>
#include <UT/UT_Plane.h>
#include <UT/UT_Quaternion.h>
#include <UT/UT_Vector3.h>

// Essentially a callback class to allow options from above GUI
// to be saved to the default file.
class GUI_API GUI_ExternalDefaultCB
{
public:
    virtual ~GUI_ExternalDefaultCB() {}
    virtual bool isDefaultToken(const char *token) = 0;
    virtual bool parseDefaultOption(const char *token, UT_IStream &is) = 0;

    virtual bool save(std::ostream &os) = 0;
};


class UT_StringArray;
class TIL_Raster;
class GUI_SnapshotImage;

class GUI_API GUI_ViewState
{
public:
                 GUI_ViewState(bool for_lops);
                ~GUI_ViewState();

    // member data accessors
    const GUI_DisplayOption     &getDisplayOptionRef() const
                                { return myOption; }
    const GUI_ViewParameter     &getViewParameterRef()  const
                                { return myView;   }
    GUI_DisplayOption   &getDisplayOptionRef()  { return myOption; }
    GUI_ViewParameter   &getViewParameterRef()  { return myView;   }

    // sets the OpenGL state according to the view parameter
    void         setViewport(RE_RenderContext r, int x, int y, int w, int h)
                                        { myView.setViewport(r, x, y, w, h); }
    void         setProjection(RE_RenderContext r)
                                        { myView.setProjection(r); }

    // methods for getting and setting the view point
    void         homeToBox(int w, int h, UT_BoundingBox &box,
                           const UT_Matrix3R *rot = NULL, bool centred = false,
                           bool zoom_in = false)
                                {
                                    fpreal minh = getDisplayOptionRef().common()
                                        .getMinHomeZoom();
                                    myView.homeToBox(w, h, minh, box, rot,
                                                     centred, zoom_in);
                                    myLeftView.homeToBox(w, h, minh, box, rot,
                                                     centred, zoom_in);
                                    myRightView.homeToBox(w, h, minh, box, rot,
                                                     centred, zoom_in);
                                }
    void         getViewport(int &l, int &r, int &b, int &t) const
                                        { myView.getViewport(l, r, b, t); }
    UT_DimRect   getViewport() const    { return myView.getViewport(); }
    void         getView(int &l, int &r, int &b, int &t) const
                                        { myView.getView(l, r, b, t); }
    UT_DimRect   getView() const        { return myView.getView(); }
    int  getViewWidth() const { return myView.getViewWidth(); }
    int  getViewHeight() const { return myView.getViewHeight(); }

    const UT_Matrix4D  &getItransformMatrix()
                                        { return myView.getItransformMatrix();}
    const UT_Matrix4D  &getTransformMatrix()
                                        { return myView.getTransformMatrix(); }
    const UT_Matrix4D  &getProjectionMatrix() const
                                        { return myView.getProjectionMatrix();}
    const UT_Matrix4D  &getRotateMatrix() const
                                        { return myView.getRotateMatrix();    }
    void         setRotateMatrix(const UT_Matrix3R &mat)
                                        { myView.setRotateMatrix(mat);        }

    int          initialized() const    { return myView.initialized(); }

    void         setOrthoFlag(int onoff)
                                    {
                                        myView.setOrthoFlag(onoff);
                                        myLeftView.setOrthoFlag(onoff);
                                        myRightView.setOrthoFlag(onoff);
                                    }
    int          getOrthoFlag() const   { return myView.getOrthoFlag();       }

    void         setApplyAspectFlag(int onoff) 
                                        { myView.setApplyAspectFlag(onoff);   }
    int          getApplyAspectFlag() const
                                        {return myView.getApplyAspectFlag();  }
    void         setAspectRatio(fpreal value) 
                                        { myView.setAspectRatio(value);       }
    fpreal       getAspectRatio() const
                                        {return myView.getAspectRatio();      }
    void         setDefaultFOV(fpreal value)
                                        { myView.setDefaultFOV(value); }
    fpreal       getDefaultFOV() const
                                        { return myView.getDefaultFOV(); }
    void         setLimits(fpreal n, fpreal f)
                                        { myView.setLimits(n, f); }

    void         rotate(UT_Axis3::axis axis, fpreal dx)
                                    { 
                                        myView.rotate(axis, dx);
                                        myLeftView.rotate(axis, dx);
                                        myRightView.rotate(axis, dx);
                                    }
    void         rotate(const UT_Vector3R &axis, fpreal dx)
                                    { 
                                        myView.rotate(axis, dx);
                                        myLeftView.rotate(axis, dx); 
                                        myRightView.rotate(axis, dx); 
                                    }
    void         rotate(const UT_Quaternion &quat)
                                    { 
                                        myView.rotate(quat);
                                        myLeftView.rotate(quat); 
                                        myRightView.rotate(quat); 
                                    }
    void         trackball(fpreal dx, fpreal dy)
                                    { 
                                        myView.trackball(dx, dy); 
                                        myLeftView.trackball(dx, dy); 
                                        myRightView.trackball(dx, dy); 
                                    }
    void         dotumble(fpreal dx, fpreal dy, int changed)
                                    { 
                                        myView.dotumble(dx, dy, changed); 
                                        myLeftView.dotumble(dx, dy, changed); 
                                        myRightView.dotumble(dx, dy, changed); 
                                    }
    void         scroll(fpreal dx, fpreal dy)
                                    { 
                                        myView.scroll(dx, dy);
                                        myLeftView.scroll(dx, dy);
                                        myRightView.scroll(dx, dy);
                                    }
    void         scroll(fpreal dx, fpreal dy,
                        const UT_InclusiveRect &viewport)
                                    { 
                                        myView.scroll(dx, dy, viewport);
                                        myLeftView.scroll(dx, dy, viewport);
                                        myRightView.scroll(dx, dy, viewport);
                                    }
    void         worldLockedScroll(const UT_Vector3R &locked_pos,
                                   fpreal dx, fpreal dy)
                                    { 
                                        // This method requires the projection
                                        // matrix to be set correctly, which is
                                        // not always the case for myLeftView
                                        // and myRightView.  Even if we could
                                        // count on that, doing it individually
                                        // for each view would tend to change
                                        // the distance between the left and
                                        // right views, which isn't what one
                                        // wants.  Instead, we just apply the
                                        // same delta to the left and right
                                        // views.
                                        UT_Vector3D old_t = myView.getT();
                                        UT_Vector3D old_p = myView.getP();

                                        myView.worldLockedScroll(
                                                locked_pos, dx, dy);

                                        UT_Vector3D delta_t =
                                                        myView.getT() - old_t;
                                        UT_Vector3D delta_p =
                                                        myView.getP() - old_p;
                                        myLeftView.setT(
                                                myLeftView.getT() + delta_t);
                                        myLeftView.setP(
                                                myLeftView.getP() + delta_p);
                                        myRightView.setT(
                                                myLeftView.getT() + delta_t);
                                        myRightView.setP(
                                                myLeftView.getP() + delta_p);
                                    }
    void         dolly(fpreal dx,
                       bool precise_zoom = false,
                       bool smooth_dolly = false)
                                    {
                                        myView.dolly(dx, precise_zoom,
                                                     smooth_dolly); 
                                        myLeftView.dolly(dx, precise_zoom,
                                                         smooth_dolly); 
                                        myRightView.dolly(dx, precise_zoom,
                                                          smooth_dolly); 
                                    }
    void         directedDolly(const UT_Vector3R &unit_worldspace_dir,
                               fpreal dx,
                               bool precise_zoom = false,
                               bool smooth_dolly = false)
                                    {
                                        myView.directedDolly(
                                            unit_worldspace_dir, dx,
                                            precise_zoom,
                                            smooth_dolly); 
                                        myLeftView.directedDolly(
                                            unit_worldspace_dir, dx,
                                            precise_zoom,
                                            smooth_dolly); 
                                        myRightView.directedDolly(
                                            unit_worldspace_dir, dx,
                                            precise_zoom,
                                            smooth_dolly); 
                                    }
    void         zoom(fpreal dx, GUI_ViewParameter::GUI_ZoomItem item,
                      bool precise_zoom = false)
                                    { 
                                        myView.zoom(dx, item, precise_zoom);
                                        myLeftView.zoom(dx, item, precise_zoom);
                                        myRightView.zoom(dx, item,precise_zoom);
                                    }
    void         zoom(fpreal dx, GUI_ViewParameter::GUI_ZoomItem item,
                      const UT_InclusiveRect &viewport,
                      bool precise_zoom = false)
                                    { 
                                        myView.zoom(dx, item, viewport,
                                                    precise_zoom);
                                        myLeftView.zoom(dx, item, viewport,
                                                        precise_zoom);
                                        myRightView.zoom(dx, item, viewport,
                                                         precise_zoom);
                                    }
    void         offsetZoom(fpreal sx, fpreal sy, fpreal dx,
                            GUI_ViewParameter::GUI_ZoomItem item,
                            bool precise_zoom = false)
                                    { 
                                        myView.offsetZoom(sx, sy, dx, item,
                                                          precise_zoom);
                                        myLeftView.offsetZoom(sx, sy, dx, item,
                                                          precise_zoom);
                                        myRightView.offsetZoom(sx, sy, dx, item,
                                                          precise_zoom);
                                    }
    void         offsetZoom(fpreal sx, fpreal sy, fpreal dx,
                            GUI_ViewParameter::GUI_ZoomItem item,
                            const UT_InclusiveRect &viewport,
                            bool precise_zoom = false)
                                    { 
                                        myView.offsetZoom(sx, sy, dx, item,
                                                          viewport,
                                                          precise_zoom);
                                        myLeftView.offsetZoom(sx, sy, dx, item,
                                                          viewport,
                                                          precise_zoom);
                                        myRightView.offsetZoom(sx, sy, dx, item,
                                                          viewport,
                                                          precise_zoom);
                                    }
    void         boxZoom(fpreal frstx, fpreal frsty, fpreal lastx, 
                         fpreal lasty, fpreal distance)
                        { myView.boxZoom(frstx,frsty,lastx,lasty, distance); }

    void         screenScroll(fpreal dx, fpreal dy)
                                    { 
                                        myView.screenScroll(dx, dy);
                                        myLeftView.screenScroll(dx, dy);
                                        myRightView.screenScroll(dx, dy);
                                    }

    void         setPrimitiveMask(GA_PrimCompat::TypeMask m) 
                                    { myOption.common().primMask(m); }
    GA_PrimCompat::TypeMask getPrimitiveMask() const 
                                    { return myOption.common().primMask(); }
    
    // Enumeration of the types of view points:
    enum GUI_ViewType
    {
        GUI_MAIN,
        GUI_LEFT,
        GUI_RIGHT,
        GUI_IMAGE
    };

    // type dependent view parameter accessor
    GUI_ViewParameter   &getViewParameter(GUI_ViewState::GUI_ViewType view_type)
                         { 
                             if( view_type == GUI_MAIN )
                                 return myView;
                             if( view_type == GUI_LEFT )
                                 return myLeftView;
                             if( view_type == GUI_RIGHT )
                                 return myRightView;
                             if( view_type == GUI_IMAGE )
                                 return myImageView;
                             return myView;
                         }

    // for general synchronization of L/R view points with the main one
    void         syncViewsWithMain()
                        { 
                            myLeftView  = myView;
                            myRightView = myView;
                        }

    // type dependent versions
    void         setViewport(GUI_ViewState::GUI_ViewType vt,
                             RE_RenderContext r, int x, int y, int w, int h)
                            { getViewParameter(vt).setViewport(r, x, y, w, h); }
    void         setProjection(GUI_ViewState::GUI_ViewType vt,
                               RE_RenderContext r)
                            { getViewParameter(vt).setProjection(r); }

    // The UT_Plane will be transformed with the inverted ViewState transform
    // matrix
    void         alignPlaneWithView(UT_Plane *plane);

    const char  *className() const;

    GUI_ViewState &operator=(const GUI_ViewState &src);

    // Method to override the default preference file name.  In order to for
    // the defaults to be loaded from this file, this must be called before
    // the first instance of this class is created.
    static void  overridePrefFile(const char *filename);        

    void         saveAsDefault();
    void         resetToDefaults();

    // setting the image that overrides the regular rendering
    void             setSnapshotImage(TIL_Raster *texture);
    TIL_Raster      *getSnapshotImage() const;

    // setting the frame information of the snapshot image 
    void             setSnapshotImageFrame( int frame );
    int              getSnapshotImageFrame() const;

    // the snapshot blending coefficient (alpha)
    void             setSnapshotFactor( float alpha);
    float            getSnapshotFactor() const;

    void             setSnapshotBlendMode(GUI_SnapshotBlendMode mode);
    GUI_SnapshotBlendMode getSnapshotBlendMode() const;

    // snapshot image flags
    void             setHideSnapshotAtSourceFrame( bool flag );
    bool             getHideSnapshotAtSourceFrame() const;

    void             setTumbling(bool tumble)   { myTumbleFlag = tumble; }
    bool             isTumbling() const         { return myTumbleFlag; }

    bool             isLopsView() const         { return myIsLops; }

    // Returns the near and far clipping planes that have saved in the pref file
    static void  getDefaultNearFarLimits(fpreal &near_limit, fpreal &far_limit);

    // Automatic near/far clip adapt is disabled when looking through a camera.
    void allowNearFarClipAdapt(bool allow)
         {
             myView.allowNearFarClipAdapt(allow);
             myLeftView.allowNearFarClipAdapt(false); //allow);
             myRightView.allowNearFarClipAdapt(false); //allow);
             // No Image view
         }
    void setSceneBounds(const UT_BoundingBoxD &bbox)
         {
             myView.setSceneBounds(bbox);
             myLeftView.setSceneBounds(bbox);
             myRightView.setSceneBounds(bbox);
         }

    void setSelectedObjectBounds(const UT_BoundingBoxD &bbox)
         {
             myView.setSelectedObjectBounds(bbox);
             myLeftView.setSelectedObjectBounds(bbox);
             myRightView.setSelectedObjectBounds(bbox);
         }
    UT_BoundingBox getSceneBounds() const
         {        
             return myView.getSceneBounds();
         }

    // Methods to manipulate the external callback class for saving/loading
    // defaults.
    static GUI_ExternalDefaultCB        *getExternalDefaultCB(bool for_lops)
                        { return externalDefaultValues[for_lops?1:0]; }
    static void         setExternalDefaultCB(GUI_ExternalDefaultCB *cb,
                                             bool for_lops)
                        { externalDefaultValues[for_lops?1:0] = cb; }

    static void         ensureDefaultsLoaded(bool is_lops);

private:
    // 0 = reg, 1 = lops
    static GUI_ViewState                *defaultValues[2];
    static GUI_ExternalDefaultCB        *externalDefaultValues[2];
    static UT_StringArray               *defaultEnabledUserOptions[2];

    // Display options for the viewport
    GUI_DisplayOption            myOption;

    // Defines the point of view for simple cameras (non-stereoscopic). 
    GUI_ViewParameter            myView;

    // For stereoscopic cameras we have two view points
    GUI_ViewParameter            myLeftView;
    GUI_ViewParameter            myRightView;

    // For the image view in LOPs, this is the camera view (myView is the 2D
    // view)
    GUI_ViewParameter            myImageView;

    // data about the snapshot image that is displayed instead of showing
    // the rendered scene (or is blended with the scene framebuffer)
    GUI_SnapshotImage           *mySnapshotImage;
    bool                         myTumbleFlag;
    bool                         myIsLops;
};

#endif