GUI_DisplayOption.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_DisplayOption.h ( GUI Library, C++)
 *
 * COMMENTS:    This class contains the options for all the different types
 *              of details (templates, footprints, etc.) and options that
 *              are common to them.
 */

#ifndef __GUI_DisplayOption__
#define __GUI_DisplayOption__

#include "GUI_API.h"
#include <UT/UT_Rect.h>
#include <UT/UT_Vector2.h>
#include <UT/UT_UniquePtr.h>
#include <RE/RE_RenderContext.h>
#include <RE/RE_TextureMap.h>
#include <UI/UI_Value.h>
#include <GR/GR_Defines.h>
#include <GR/GR_CommonDispOption.h>
#include <GR/GR_DisplayOption.h>
#include "GUI_RenderCommon.h"

#ifdef USE_VULKAN
#include <RV/RV_Type.h>
class RV_Render;
#endif

class GUI_RotoscopeData;
class GR_DisplayOption;

const int GUI_NUM_DISPLAY_SETS       = 6;
const int GUI_NUM_DISPLAY_SCENE_SETS = 3;
const int GUI_NUM_DISPLAY_MODEL_SETS = 3;

/// Context specific display options for geometry states
enum GUI_DisplaySetType
{
    GUI_SCENE_OBJECT,
    GUI_SELECTED_SCENE_OBJECT,
    GUI_GHOST_SCENE_OBJECT,
    // ---- obj/model break
    GUI_DISPLAY_MODEL,
    GUI_CURRENT_MODEL,
    GUI_TEMPLATE_MODEL
};

#define ANY_FLAG_ACTIVE_IN_SETS(METHOD)                                 \
    bool METHOD##Any() const                                            \
         { return ((*this)[GUI_SCENE_OBJECT].METHOD() ||                \
                   (*this)[GUI_SELECTED_SCENE_OBJECT].METHOD() ||       \
                   (*this)[GUI_GHOST_SCENE_OBJECT].METHOD() ||          \
                   (*this)[GUI_DISPLAY_MODEL].METHOD() ||               \
                   (*this)[GUI_CURRENT_MODEL].METHOD() ||               \
                   (*this)[GUI_TEMPLATE_MODEL].METHOD()); }


/// Display options object that contains all high-level viewport display
/// settings, and contains the objects with context-specific display options
/// and common drawing options.
class GUI_API GUI_DisplayOption
{
public:
              GUI_DisplayOption(bool for_lops_view);
             ~GUI_DisplayOption();

    GUI_DisplayOption           &operator=(const GUI_DisplayOption &opt);

    /// Context-specific geometry-specific display options. If a display set
    /// follows another set, it will be remapped to return that set.
    /// @{
          GR_DisplayOption      &operator[](GUI_DisplaySetType type)
                                { return *myDisplaySet[myDisplaySetMap[type]]; }
    const GR_DisplayOption      &operator[](GUI_DisplaySetType type) const
                                { return *myDisplaySet[myDisplaySetMap[type]]; }
    /// @}
    
    /// Direct cccess to the display set, without any mapping.
    GR_DisplayOption    &getDisplaySet(GUI_DisplaySetType type)
                                { return *myDisplaySet[type]; }

    /// Low-level drawing display options common to all geometry contexts
    /// @{
    const GR_CommonDispOption &common() const { return myCommonOptions; }
          GR_CommonDispOption &common()       { return myCommonOptions; }
    /// @}

    /// Return true if the load/save was successful, and false otherwise.
    /// @{
    bool         save(std::ostream &) const;
    bool         load(UT_IStream &);
    /// @}

    /// Remap the display option set to another set.
    void                setDisplaySetRemap(GUI_DisplaySetType follower,
                                           GUI_DisplaySetType reference)
                            { myDisplaySetMap[follower] = reference; }

    /// Query which display set this set is following. If none, it will refer
    /// to itself.
    GUI_DisplaySetType  getDisplaySetRemap(GUI_DisplaySetType t) const
                            { return myDisplaySetMap[t]; }

    /// Scene custom display option support - set and query scene options
    /// @{
    void                enableSceneOption(const char *name, bool enable);
    bool                isSceneOptionEnabled(const char *name) const;
    /// @}

    void                setRenderType(GR_RenderVersion t)
                           { myRenderType = t; }
    GR_RenderVersion    getRenderType() const  { return myRenderType; }

    // These flags are stored here because they deal with different concepts
    // unknown to GR.  The flags at the GR level should only be used by GR when
    // it renders a specific detail.
    bool         showSelected() const     { return myFlags.showSelected; }
    bool         showNonSelected() const  { return myFlags.showNonSelected; }
    bool         showTemplates() const    { return myFlags.showTemplates; }
    bool         showFootprints() const   { return myFlags.showFootprints; }
    bool         showCurrentOutput() const { return myFlags.showCurrentOutput; }
    bool         showDisplay() const      { return myFlags.showDisplay; }
    bool         showGuides() const       { return myFlags.showGuides; }
    bool         showObjectNames() const  { return myFlags.showObjectNames; }
    bool         showFullNames() const    { return myFlags.showFullNames; }
    bool         drawOrigin() const       { return myFlags.drawOrigin; }
    bool         drawStickyOrigin() const { return myFlags.drawStickyOrigin; }
    bool         drawViewPivot() const    { return myFlags.drawViewPivot; }
    bool         drawWalls() const        { return myFlags.drawWalls; }
    bool         drawXYPlane() const      { return myFlags.drawXYPlane; }
    bool         drawXZPlane() const      { return myFlags.drawXZPlane; }
    bool         drawYZPlane() const      { return myFlags.drawYZPlane; }
    bool         drawFieldGuide() const   { return myFlags.drawFieldGuide; }
    bool         drawSafeArea() const     { return myFlags.drawSafeArea; }
    bool         drawBackgrounds() const  { return myFlags.drawBackgrounds; }
    bool         drawEnvironmentMaps() const
                                    { return myFlags.drawEnvironmentMaps; }
    bool         drawFilteredBackgrounds() const
                                    { return myFlags.drawFilteredBackgrounds; }
    bool         showIKCriticalZones() const
                                    { return myFlags.showIKCriticalZones; }
    bool         getDrawCameraMask() const
                                          { return myFlags.drawCameraMask; }
    bool         drawBadges() const       { return myFlags.drawBadges; }

    bool         drawVertexAttrib2D() const
                                        { return myFlags.drawVertexAttrib2D; }
    bool         autoDetectAttribType2D() const
                                { return myFlags.autoDetectAttribType2D; }

    bool         drawSpecular() const     { return myFlags.drawSpecular; }
    bool         drawMultiTexture() const { return common().drawMultiTexture();}

    bool         applySelectMask() const  { return myFlags.applySelectMask; }

    bool         drawXRay() const         { return myFlags.drawXRay; }
    bool         xrayQuality() const      { return myFlags.xrayQuality; }
    bool         drawObjectOrigins() const { return myFlags.drawObjOrigins; }
    bool         showMaterials() const    { return common().showMaterials(); }
    bool         useMaterialOverrides() const { return myFlags.useOverrides; }
    bool         mssEnable() const        { return myFlags.mssEnable; }
    bool         mssPerPrim() const       { return myFlags.mssPerPrim; }
    bool         mssPacked() const        { return myFlags.mssPacked; }
    int          objectMaterialLimit() const { return myObjectMaterialLimit; }
    fpreal       xrayWireStrength() const { return myXRayWireStrength; }
    
    enum gui_MatAssignMode
    {
        MAT_ALWAYS = 0,
        MAT_NO_PLAYBACK = 1,
        MAT_MANUAL = 2
    };
    gui_MatAssignMode materialAssignMode() const   { return myMatAssignMode; }
    void          materialAssignMode(gui_MatAssignMode mode)
                                                     { myMatAssignMode = mode; }
    bool          materialUpdate() const      { return myMatUpdate; }
    void          materialUpdate(bool update) { myMatUpdate = update; }
        
    
    // the threshold a shading mode is set to change when modifying view
    
    void         showSelected(bool onoff)     { myFlags.showSelected    =onoff;}
    void         showNonSelected(bool onoff)  { myFlags.showNonSelected =onoff;}
    void         showTemplates(bool onoff)    { myFlags.showTemplates   =onoff;}
    void         showFootprints(bool onoff)   { myFlags.showFootprints  =onoff;}
    void         showCurrentOutput(bool onoff)
                                        { myFlags.showCurrentOutput = onoff;}
    void         showDisplay(bool onoff)      { myFlags.showDisplay     =onoff;}
    void         showGuides(bool onoff)       { myFlags.showGuides      =onoff;}
    void         showObjectNames(bool onoff)  { myFlags.showObjectNames =onoff;}
    void         showFullNames(bool onoff)    { myFlags.showFullNames   =onoff;}
    void         drawOrigin(bool onoff)       { myFlags.drawOrigin      =onoff;}
    void         drawStickyOrigin(bool onoff) { myFlags.drawStickyOrigin=onoff;}
    void         drawViewPivot(bool onoff)    { myFlags.drawViewPivot   =onoff;}
    void         drawWalls(bool onoff)        { myFlags.drawWalls       =onoff;}
    void         drawXYPlane(bool onoff)      { myFlags.drawXYPlane     =onoff;}
    void         drawXZPlane(bool onoff)      { myFlags.drawXZPlane     =onoff;}
    void         drawYZPlane(bool onoff)      { myFlags.drawYZPlane     =onoff;}
    void         drawFieldGuide(bool onoff)   { myFlags.drawFieldGuide  =onoff;}
    void         drawSafeArea(bool onoff)     { myFlags.drawSafeArea    =onoff;}
    void         drawBackgrounds(bool onoff)  { myFlags.drawBackgrounds =onoff;}
    void         drawEnvironmentMaps(bool onoff) 
                                       { myFlags.drawEnvironmentMaps    =onoff;}
    void         drawFilteredBackgrounds(bool onoff)
                                       { myFlags.drawFilteredBackgrounds=onoff;}
    void         showIKCriticalZones(bool onoff)
                                       { myFlags.showIKCriticalZones    =onoff;}
    void         setDrawCameraMask(bool onoff)
                                       { myFlags.drawCameraMask         =onoff;}
    void         drawBadges(bool onoff)       { myFlags.drawBadges      =onoff;}
    void         drawVertexAttrib2D(bool onoff)
                                        { myFlags.drawVertexAttrib2D = onoff; }
    void         autoDetectAttribType2D(bool onoff)
                                { myFlags.autoDetectAttribType2D = onoff; }
    void         drawSpecular(bool onoff)
                                        { myFlags.drawSpecular = onoff; }
    void         drawMultiTexture(bool onoff)
                                        { common().drawMultiTexture(onoff); }
    void         applySelectMask(bool onoff)
                                        { myFlags.applySelectMask = onoff; }
    void         drawXRay(bool xray)      { myFlags.drawXRay = xray; }
    void         xrayQuality(bool q)      { myFlags.xrayQuality = q; }
    void         xrayWireStrength(fpreal w) { myXRayWireStrength = w; }
    void         drawObjectOrigins(bool org) { myFlags.drawObjOrigins = org; }
    void         showMaterials(bool show) { common().showMaterials(show); }
    void         useMaterialOverrides(bool ovr) { myFlags.useOverrides = ovr; }
    void         mssEnable(bool mss)     { myFlags.mssEnable = mss; }
    void         mssPerPrim(bool mpp)    { myFlags.mssPerPrim = mpp; }
    void         mssPacked(bool mp)      { myFlags.mssPacked = mp; }
    void         objectMaterialLimit(int m)
                                        { myObjectMaterialLimit=SYSmax(1,m); }

    void         handleHighlightSize(int hl)
                                { myHandleHighlightSize = SYSclamp(hl, 0, 2); }
    int          handleHighlightSize() const { return myHandleHighlightSize; }
    void         originGnomonSize(fpreal size)
                                { myOriginGnomonSize = SYSmax(size, 0.0); }
    fpreal       originGnomonSize() const { return myOriginGnomonSize; }
    void         floatingGnomonSize(fpreal size)
                                { myFloatingGnomonSize = SYSmax(size, 0.0); }
    fpreal       floatingGnomonSize() const { return myFloatingGnomonSize; }
    
    /// set/query enable/disable of shading mode change
    /// @{
    void         moveModeOn(bool onoff) { myMoveModeOn = onoff; }
    bool         moveModeOn() const     { return myMoveModeOn; }
    /// @}

    void         setUVMapFile(const UT_StringRef &uvmap);
    const UT_StringRef &getUVMapFile() const { return myUVMapFile; }

    void         setUVMapScale(fpreal scale);
    fpreal       getUVMapScale() const { return myUVMapScale; }
    
    /// Rotoscoping background image set/query methods
    /// @{
    RE_TextureHolder getRotoTexture(RE_Render *r,
                                    GUI_RotoView type,
                                    float &quality,
                                    float &aspect_ratio,
                                    UT_DimRect *udim_area = nullptr) const;

#ifdef USE_VULKAN
    bool            getRotoVkTexture(RV_Render *r,
                                     RV_TextureRef &tex_ref,
                                     RV_ImageDim &tex_type,
                                     GUI_RotoView type,
                                     float &quality,
                                     float &aspect_ratio) const;
#endif
                                     
    
    void         getRotoResolution(GUI_RotoView type, UT_Vector2i &res);

    bool         setRotoFileParms(GUI_RotoView type,
                                  const char *file, float quality);
    bool         setRotoCopParms(GUI_RotoView type,
                                 const char *path, float quality);
    void         setRotoSource(GUI_RotoView type,bool file);

    void         setRotoTime(fpreal t);
    bool         isRotoTimeDependent(GUI_RotoView type) const;
    
    fpreal       getRotoQuality() const;
    void         setRotoQuality(fpreal q);

    void         setRotoPath(GUI_RotoView type,
                             bool file_path, const char *path);
    bool         isRotoFile(GUI_RotoView type) const;
    const char  *getRotoCopPath(GUI_RotoView type) const;
    const char  *getRotoFilePath(GUI_RotoView type) const;

    UI_Value    &getRotoCopCookNotify(GUI_RotoView type);
    UI_Value    &getRotoCopNameChangeNotify(GUI_RotoView type);

    void         setForegroundImageEnable(bool enable)
                 { myFlags.showForegroundImage = enable; }
    bool         getForegroundImageEnable() const
                 { return myFlags.showForegroundImage; }
    void         setForegroundImage(const UT_StringRef &file_node_path)
                 { myFGImage = file_node_path; }
    const UT_StringRef &getForegroundImage() const { return myFGImage; }
    void         setForegroundImageDepth(bool enable)
                 { myFlags.useForegroundDepth = enable; }
    bool         getForegroundImageDepth() const
                 { return myFlags.useForegroundDepth; }
    void         setForegroundDepthPlane(const UT_StringRef &plane)
                 { myFGDepthPlane = plane; }
    const UT_StringRef &getForegroundDepthPlane() const
                 { return myFGDepthPlane; }
    enum FGDepthStyle
    {
        DEPTH_LINEAR,
        DEPTH_NDC,
        DEPTH_OPENGL,
        DEPTH_CAM_POS,
        DEPTH_WORLD_POS
    };
    void         setForegroundDepthStyle(FGDepthStyle style)
                 { myFGDepthStyle = style; }
    FGDepthStyle getForegroundDepthStyle() const
                 { return myFGDepthStyle; }

    void         foregroundOpacity(fpreal opacity)
                 { myFGOpacity = SYSclamp(opacity, 0.0, 1.0); }
    fpreal       foregroundOpacity() const
                 { return myFGOpacity; }

    void         getImageMinUV(float arr[2]) const
                 {
                     arr[0] = myImageMinUV[0];
                     arr[1] = myImageMinUV[1]; 
                 }
    void         setImageMinUV(float arr[2])
                 {
                     myImageMinUV[0] = arr[0];
                     myImageMinUV[1] = arr[1];
                 }
    void         getImageMaxUV(float arr[2]) const
                 {
                     arr[0] = myImageMaxUV[0];
                     arr[1] = myImageMaxUV[1]; 
                 }
    void         setImageMaxUV(float arr[2])
                 {
                     myImageMaxUV[0] = arr[0];
                     myImageMaxUV[1] = arr[1];
                 }
    
    void         getImageOffset(GUI_RotoView view, float arr[2]) const
                 {
                     arr[0] = myRotoViews[view].myImageOffset[0];
                     arr[1] = myRotoViews[view].myImageOffset[1];
                 }
    void         setImageOffset(GUI_RotoView view, float arr[2])
                 {
                     myRotoViews[view].myImageOffset[0] = arr[0];
                     myRotoViews[view].myImageOffset[1] = arr[1];
                 }
    void         getImageScale(GUI_RotoView view, float arr[2]) const
                 {
                     arr[0] = myRotoViews[view].myImageScale[0];
                     arr[1] = myRotoViews[view].myImageScale[1];
                 }
    void         setImageScale(GUI_RotoView view, float arr[2])
                 {
                     myRotoViews[view].myImageScale[0] = arr[0];
                     myRotoViews[view].myImageScale[1] = arr[1];
                 }
    
    float        getOpacity(GUI_RotoView view) const
                 { return myRotoViews[view].myOpacity; }
    void         setOpacity(GUI_RotoView view, float opacity)
                 { myRotoViews[view].myOpacity = opacity; }

    enum class ImageFitMode
    {
        /// Fit the image so that the horizontal dimension fits within the viewport
        ///   _________
        /// ||_________||
        /// ||         ||
        /// ||_________||
        /// ||_________||
        ///
        HORIZONTAL = 0,

        /// Fit the image so that the vertical dimension fits within the viewport
        ///  ___  _________  ___
        /// |   ||         ||   |
        /// |   ||         ||   |
        /// |   ||         ||   |
        /// |___||_________||___|
        ///
        VERTICAL,

        /// Stretch the image to fit within the viewport
        ///   _________
        /// ||         ||
        /// ||         ||
        /// ||         ||
        /// ||_________||
        ///
        FILL,

        /// Scale the image to so that the longest dimension fits within the viewport
        ///   _________
        /// ||_________||
        /// ||         ||
        /// ||_________||
        /// ||_________||
        ///
        SCALE,

        NUM_FIT_MODES
    };

    ImageFitMode
                 getImageFitMode(GUI_RotoView view) const
                 { return myRotoViews[view].myImageFitMode; }
    void         setImageFitMode(GUI_RotoView view, ImageFitMode fit_mode)
                 { myRotoViews[view].myImageFitMode = fit_mode; }

    float        getBrightness(GUI_RotoView view) const
                 { return myRotoViews[view].myBrightness; }
    void         setBrightness(GUI_RotoView view, float brightness)
                 { myRotoViews[view].myBrightness = brightness; }

    void         autoPlaceImage(GUI_RotoView view, bool onoff) 
                 { myRotoViews[view].myAutoPlaceImage = onoff; }
    bool         autoPlaceImage(GUI_RotoView view) const
                 { return myRotoViews[view].myAutoPlaceImage; }

    void         envMapImage(GUI_RotoView view, bool onoff) 
                 { myRotoViews[view].myEnvMapImage = onoff; }
    bool         envMapImage(GUI_RotoView view) const
                 { return myRotoViews[view].myEnvMapImage; }

    int          isRotoFileVideo(GUI_RotoView view) const;

    int          getRotoVideoClipStartFrame(GUI_RotoView view) const;
    void         setRotoVideoClipStartFrame(GUI_RotoView view, int start_frame);

    int          getRotoVideoClipEndFrame(GUI_RotoView view) const;
    void         setRotoVideoClipEndFrame(GUI_RotoView view, int end_frame);
    
    fpreal       getRotoVideoPlaybackStartFrame(GUI_RotoView view) const;
    void         setRotoVideoPlaybackStartFrame(GUI_RotoView view, fpreal start_frame);

    fpreal       getRotoVideoPlaybackSpeed(GUI_RotoView view) const;
    void         setRotoVideoPlaybackSpeed(GUI_RotoView view, fpreal speed);

    const char * getRotoVideoColorSpace(GUI_RotoView view) const;
    void         setRotoVideoColorSpace(GUI_RotoView view, const char *color_space);

    bool         getRotoVideoFrameRateEnabled(GUI_RotoView view) const;
    void         setRotoVideoFrameRateEnabled(GUI_RotoView view, bool enabled);

    fpreal       getRotoVideoFrameRate(GUI_RotoView view) const;
    void         setRotoVideoFrameRate(GUI_RotoView view, fpreal frame_rate);

    int          getRotoVideoRotation(GUI_RotoView view) const;
    bool         getRotoVideoIsRotated(GUI_RotoView view) const;

    bool         getRotoVideoIsTopFirst(GUI_RotoView view) const;

    int          getRotoVideoSourceFrameCount(GUI_RotoView view) const;
    fpreal       getRotoVideoSourceFrameRate(GUI_RotoView view) const;

    void         setUseFixedImageRes(bool use_fixed)
                 { myUseFixedImageRes = use_fixed; }
    bool         getUseFixedImageRes() const
                 { return myUseFixedImageRes; }
    void         setUseViewportRes(bool use_vp)
                 { myUseViewportRes = use_vp; }
    bool         getUseViewportRes() const
                 { return myUseViewportRes; }
    void         setFixedImageRes(int w, int h)
                 {
                     if(myForLopsView)
                         myFixedImageRes.assign(w,h);
                 }
    UT_Vector2i  getFixedImageRes() const
                 { return myForLopsView ? myFixedImageRes : UT_Vector2i(0,0); }
    void         setCurrentImageRes(int w, int h)
                 { myCurrentImageRes.assign(w,h); }
    UT_Vector2i  getCurrentImageRes() const
                 { return myForLopsView ? myCurrentImageRes :UT_Vector2i(0,0); }
    void         setImageResFraction(fpreal fraction)
                 { myImageResFraction =fraction; }
    fpreal       getImageResFraction() const
                 { return myImageResFraction; }

    bool         getCameraCropMask() const { return myCameraCropMask; }
    void         setCameraCropMask(bool crop) { myCameraCropMask = crop; }

    static const char *getRotoViewName(GUI_RotoView view);
    /// @}
 
    /// Methods to query/change the scale at which handles are drawn.
    /// @{
    static float getHandleScale() { return theHandleScale; }
    static void  setHandleScale(float v)
                        { theHandleScale = SYSclamp(v, 0.01f, 1.0f); }
    /// @}

    // This method is called when user options are being destroyed.
    void         removeUserOption(int option_id);

    /// Refresh the cached version keys for the enabled user options to reflect
    /// the most up-to-date version.
    void         refreshUserOptionVersions();

    /// State which switches the geometry context display options between the
    /// Scene and Model display sets. When at the object level, the scene is
    /// used.
    /// @{
    bool         isObjectLevel() const   { return myNoSaveFlags.isObjectLevel; }
    void         setObjectLevel(bool onoff);
    /// @}

    /// The select mask is set when the user is in a "select" state to
    /// automatically turn on some decorations.  The mask is used to
    /// temporarily tweak the appropriate display options, and does not,
    /// in and of itself, invalidate display lists.
    /// @{
    unsigned     getSelectMask() const { return mySelectMask; }
    void         setSelectMask(unsigned mask) { mySelectMask = mask; }
    /// @}

    /// This value is changed when the scene is switched from obj to sop/dop
    /// level.
    UI_Value    &getObjectLevelNotify() { return myObjectLevelNotify; }

    /// For the OpenGL ROP only: Allows a single stereo camera to be rendered.
    enum gui_StereoPass
    {
        GUI_DISP_STEREO_BOTH,
        GUI_DISP_STEREO_LEFT,
        GUI_DISP_STEREO_RIGHT
    };

    /// Allow rendering of a single stereo camera eye.
    /// @{
    void         setSeparateStereoRender(gui_StereoPass pass)
                    { myStereoPass = pass; }
    bool         isStereoLeftRender() const
                    { return (myStereoPass == GUI_DISP_STEREO_BOTH ||
                              myStereoPass == GUI_DISP_STEREO_LEFT); }
    bool         isStereoRightRender() const
                    { return (myStereoPass == GUI_DISP_STEREO_BOTH ||
                              myStereoPass == GUI_DISP_STEREO_RIGHT); }
    /// @}

    /// Returns true if any of the geometry contexts have this option set.
    /// @{
    ANY_FLAG_ACTIVE_IN_SETS(drawPointCoincident);
    ANY_FLAG_ACTIVE_IN_SETS(drawPointMarkers);
    ANY_FLAG_ACTIVE_IN_SETS(uvFillOverlap);
    /// @}

    /// Auto-select quality/preformance presets based on hardware queries.
    /// Only works at startup.
    void         updateOptionsForHardware(RE_RenderContext r);


    /// Returns true if the passed options are compatible with these options,
    /// meaning that update() does not need to be called on GR_Primitives if
    /// 'opt' is used after this option. This could happen if 'opt' had a marker
    /// on that required an attribute that this options set does not.
    bool         compatibleWith(const GUI_DisplayOption &opt) const;

    void         setUseHeadlight(bool headlight)
                    { myUseHeadlight = headlight; }
    bool         useHeadlight() const { return myUseHeadlight; }

    enum HeadlightType
    {
        HEADLIGHT,
        DOMELIGHT,
        PHYSICAL_SKY,
        THREE_POINT,
    };

    void         setHeadlightType(HeadlightType type) { myHeadlightType = type; }
    HeadlightType getHeadlightType() const { return myHeadlightType; }

    // Headlight parms (distant light)
    struct HeadlightParms
    {
        UT_Vector3F Direction; // OpenGL
        fpreal Intensity =  1.0;
        fpreal Ambient = 0.02; // VK
        fpreal Azimuth = 22;   // VK
        fpreal Altitude = 22;  // VK
        fpreal Softness = 0.0; // VK
        bool   Specular = true;
    };

    HeadlightParms &headlightParms() { return myHeadlightParms; }
    const HeadlightParms &headlightParms() const { return myHeadlightParms; }

    // Domelight parms (straight env light)
    struct DomelightParms
    {
        UT_StringHolder File;
        UT_Vector3F Rotation;
        UT_Vector3F Tint;
        fpreal      Intensity = 1.0;
        fpreal      Exposure = 0.0;
        bool        ShowBackground = false;
    };

    DomelightParms &domelightParms() { return myDomelightParms; }
    const DomelightParms &domelightParms() const { return myDomelightParms; }

    UT_StringHolder getDomelightMapPath() const;
    
    // Physical sky headlight (distant + dome)
    struct PhysicalSkyParms
    {
        fpreal Azimuth = 0.0;
        fpreal Altitude = 45.0;
        fpreal Intensity = 1.0;
        fpreal Exposure = 0.0;
        bool   UseSun = true;
        fpreal Size = 0.51;
        bool   UseSky = true;
        fpreal Turbidity = 3.0;
        UT_Vector3F GroundAlbedo;
        fpreal HorizonBlur = 0.5;
        fpreal SunIntensity = 1.0;
        fpreal SkyIntensity = 1.0;
        bool   ShowBackground = false;
    };
    PhysicalSkyParms &physicalSkyParms() { return myPhysicalSkyParms; }
    const PhysicalSkyParms &physicalSkyParms() const { return myPhysicalSkyParms; }

    struct ThreePointParms
    {
        UT_Vector3F KeyColor;
        UT_Vector3F FillColor;
        UT_Vector3F BackColor;
        fpreal KeyIntensity = 1.0;
        fpreal KeyExposure = 0.0;
        fpreal KeyAltitude = 33.0;
        fpreal KeyAzimuth = 55.0;
        fpreal FillIntensity = 0.4;
        fpreal FillExposure = 0.0;
        fpreal FillAltitude = 30.0;
        fpreal FillAzimuth = -80.0;
        fpreal BackIntensity = 0.5;
        fpreal BackExposure = 0.0;
        fpreal BackAltitude = 35.0;
        fpreal BackAzimuth = -170.0;
    };
    ThreePointParms &threePointParms() { return myThreePointParms; }
    const ThreePointParms &threePointParms() const { return myThreePointParms; }
    
    void         setHeadlightParmsDirty(bool dirty) { myHeadlightDirty =dirty; }
    bool         areHeadlightParmsDirty() const { return myHeadlightDirty; }

    void         dirtyPhysicalSkyMap() { myPhysicalSkyFileDirty = true; }
    UT_StringHolder createPhysicalSkyMapFile() const;  
    
    void         setHeadlightHighQuality(bool hq) { myHeadlightHQ = hq; }
    bool         getHeadlightHighQuality() const { return myHeadlightHQ; }

    void         setHQLightLimit(int nlights) { myHQLightLimit = nlights; }
    int          getHQLightLimit() const { return myHQLightLimit; }
    bool         hasHQLightLimit() const { return myHQLightLimit > 0; }
    void         setShadowMapMemMB(int mem) { myShadowMapMemMB = SYSmax(1,mem);}
    int          getShadowMapMemMB() const { return myShadowMapMemMB;}
    void         setShadowMapGenTime(fpreal t)
                                          { myShadowMapGenTime=SYSmax(0.0,t); }
    fpreal       getShadowMapGenTime() const { return myShadowMapGenTime; }
    void         setLightSamplingLimit(int limit) {myLightSampleLimit = limit;}
    int          getLightSamplingLimit() const { return myLightSampleLimit; }
    bool         hasLightSamplingLimit() const { return myLightSampleLimit>0; }
    void         setFastInteractiveHQLight(bool e)
                                        { myFlags.myFastHQIntLight = e; }
    bool         getFastInteractiveHQLight() const
                                        { return myFlags.myFastHQIntLight; }

    void         setDOFEnable(bool dof) { myFlags.dofEnable = dof; }
    bool         isDOFEnabled() const   { return myFlags.dofEnable; }
    enum DOFBokeh
    {
        DOF_NO_BOKEH,
        DOF_CIRCLE_BOKEH,
        DOF_TEXTURE_BOKEH
    };
    void         setDOFBokeh(DOFBokeh b) { myDOFBokeh = b; }
    DOFBokeh     getDOFBokeh() const     { return myDOFBokeh; }
    void         setDOFTexture(const UT_StringRef &tex) { myDOFTex = tex; }
    const UT_StringRef &getDOFTexture() const  { return myDOFTex; }
    fpreal       getDOFBokehAspect() const { return myDOFBokehAspect; }
    void         setDOFBokehAspect(fpreal a) { myDOFBokehAspect=SYSmax(a,0.01); }
    fpreal       getDOFBokehBoost() const { return myDOFBokehBoost; }
    void         setDOFBokehBoost(fpreal b) { myDOFBokehBoost = b; }

    // Uniform fog
    void         setUniformFogEnable(bool fog) { myFlags.uniformFogEnable=fog; }
    bool         isUniformFogEnabled() const { return myFlags.uniformFogEnable;}
    void         setUniformFogDensity(fpreal d) { myUniformFog.myFogDensity=d; }
    fpreal       getUniformFogDensity() const{return myUniformFog.myFogDensity;}
    void         setUniformFogOpacity(fpreal d) { myUniformFog.myFogOpacity=d; }
    fpreal       getUniformFogOpacity() const{return myUniformFog.myFogOpacity;}
    void         setUniformFogColor(const UT_Vector3F &c)
                                                { myUniformFog.myFogColor = c; }
    UT_Vector3F  getUniformFogColor() const { return myUniformFog.myFogColor; }
    void         setUniformFogStart(fpreal s) { myUniformFog.myFogStart = s; }
    fpreal       getUniformFogStart() const { return myUniformFog.myFogStart; }
    void         setUniformFogEnd(fpreal e) { myUniformFog.myFogEnd = e; }
    fpreal       getUniformFogEnd() const   { return myUniformFog.myFogEnd; }
    int          getUniformFogHeightMode() const
                      { return myUniformFog.myFogHeightMode; }
    void         setUniformFogHeightMode(int m)
                      { myUniformFog.myFogHeightMode = SYSclamp(m,-1,1); }
    fpreal       getUniformFogHeight() const { return myUniformFog.myFogHeight;}
    void         setUniformFogHeight(fpreal h) { myUniformFog.myFogHeight = h; }
    fpreal       getUniformFogFalloff() const
                      { return myUniformFog.myFogFalloff; }
    void         setUniformFogFalloff(fpreal f)
                      { myUniformFog.myFogFalloff = f; }
    void         setUniformFogIntensity(fpreal f)
                      { myUniformFog.myFogIntensity=SYSmax(0.0,f); }
    fpreal       getUniformFogIntensity() const
                      { return myUniformFog.myFogIntensity; }

    void         setUniformFogSunBloom(fpreal f) { myUniformFogSunBloom = f; }
    fpreal       getUniformFogSunBloom() const { return myUniformFogSunBloom; }
    void         setUniformFogUseSun(bool d) { myUniformFogUseSun = d; }
    bool         getUniformFogUseSun() const { return myUniformFogUseSun; }
    void         setUniformFogUseClip(bool d)
                     { myUniformFogUseClip = d; }
    bool         getUniformFogUseClip() const
                     { return myUniformFogUseClip; }
    void         setUniformFogClipDistance(fpreal d)
                     { myUniformFogClipDistance = d; }
    fpreal       getUniformFogClipDistance() const
                     { return myUniformFogClipDistance; }


    // Volume Fog
    void         setVolumeFogEnable(bool fog) { myFlags.volumeFogEnable=fog; }
    bool         isVolumeFogEnabled() const { return myFlags.volumeFogEnable;}
    void         setVolumeFogDensity(fpreal d) { myVolumeFog.myFogDensity=d; }
    fpreal       getVolumeFogDensity() const{return myVolumeFog.myFogDensity;}
    void         setVolumeFogOpacity(fpreal d) { myVolumeFog.myFogOpacity=d; }
    fpreal       getVolumeFogOpacity() const{return myVolumeFog.myFogOpacity;}
    void         setVolumeFogColor(const UT_Vector3F &c)
                                                { myVolumeFog.myFogColor = c; }
    UT_Vector3F  getVolumeFogColor() const { return myVolumeFog.myFogColor; }
    void         setVolumeFogStart(fpreal s) { myVolumeFog.myFogStart = s; }
    fpreal       getVolumeFogStart() const { return myVolumeFog.myFogStart; }
    void         setVolumeFogEnd(fpreal e) { myVolumeFog.myFogEnd = e; }
    fpreal       getVolumeFogEnd() const   { return myVolumeFog.myFogEnd; }
    int          getVolumeFogHeightMode() const
                      { return myVolumeFog.myFogHeightMode; }
    void         setVolumeFogHeightMode(int m)
                      { myVolumeFog.myFogHeightMode = SYSclamp(m,-1,1); }
    fpreal       getVolumeFogHeight() const { return myVolumeFog.myFogHeight;}
    void         setVolumeFogHeight(fpreal h) { myVolumeFog.myFogHeight = h; }
    fpreal       getVolumeFogFalloff() const
                      { return myVolumeFog.myFogFalloff; }
    void         setVolumeFogFalloff(fpreal f)
                      { myVolumeFog.myFogFalloff = f; }
    void         setVolumeFogIntensity(fpreal f)
                      { myVolumeFog.myFogIntensity=SYSmax(0.0,f); }
    fpreal       getVolumeFogIntensity() const
                      { return myVolumeFog.myFogIntensity; }
    int          getVolumeFogQuality() const { return myVolumeFogQuality; }
    void         setVolumeFogQuality(int q)
                                     { myVolumeFogQuality = SYSclamp(q, 0,3); }
    void         setVolumeFogLightScatter(fpreal para, fpreal perp)
                        {
                            myVolumeFogScatterPara = SYSmax(0.0, para);
                            myVolumeFogScatterPerp = SYSmax(0.0, perp);
                        }
    void         getVolumeFogLightScatter(fpreal &para, fpreal &perp) const
                        {
                            para = myVolumeFogScatterPara;
                            perp = myVolumeFogScatterPerp;
                        }

    void         setBloomEnable(bool e) { myFlags.bloom = e; }
    bool         isBloomEnabled() const { return myFlags.bloom; }
    void         setBloomScale(fpreal sc) { myBloomScale = sc; }
    fpreal       getBloomScale() const    { return myBloomScale; }
    void         setBloomIntensity(fpreal i) { myBloomIntensity = i; }
    fpreal       getBloomIntensity() const   { return myBloomIntensity; }
    void         setBloomThreshold(fpreal th) { myBloomThreshold = th; }
    fpreal       getBloomThreshold() const   { return myBloomThreshold; }

    void         setFogNode(const char *node) { myFogNode = node; }
    const UT_StringRef &getFogNode() const { return myFogNode; }

    enum DefaultMaterialType
    {
        DEFAULT_MATERIAL_SIMPLE = 0,
        DEFAULT_MATERIAL_MATCAP
    };
    void         setDefaultMaterialType(DefaultMaterialType type);
    void         setDefaultMatCapFile(const UT_StringRef &tex_filepath);
    void         setDefaultMatCapIntensity(fpreal intensity);
    void         setDefaultMaterialDiffuse(UT_Color col);
    void         setDefaultMaterialSpecular(UT_Color col);
    void         setDefaultMaterialAmbient(UT_Color col);
    void         setDefaultMaterialEmission(UT_Color col);
    void         setDefaultMaterialRoughness(fpreal rough);
    void         setDefaultMaterialSpecRoughness(fpreal srough);

    DefaultMaterialType getDefaultMaterialType() const
                                        { return myDefaultMatType; }
    const UT_StringRef &getDefaultMatCapFile() const
                                        { return myDefaultMatCapFile; }
    fpreal       getDefaultMatCapIntensity() const
                                        { return myDefaultMatCapIntensity; }
    UT_Color     getDefaultMaterialDiffuse() const { return myDefaultDiffuse; }
    UT_Color     getDefaultMaterialSpecular() const{ return myDefaultSpecular; }
    UT_Color     getDefaultMaterialAmbient() const { return myDefaultAmbient; }
    UT_Color     getDefaultMaterialEmission() const{ return myDefaultEmission; }
    fpreal       getDefaultMaterialRoughness() const{ return myDefaultRough; }
    fpreal       getDefaultMaterialSpecRoughness() const
                                                  { return myDefaultSpecRough; }

    bool         isDefaultMaterialDirty() const{ return myDefaultMaterialDirty;}
    void         clearDefaultMaterialDirty() { myDefaultMaterialDirty=false;}

    bool         isDefaultMatCapDirty() const{ return myDefaultMatCapDirty;}
    bool         clearDefaultMatCapDirty(){ return myDefaultMatCapDirty=false;}

    void         forceMSSUpdate(bool) { myMSSUpdateSerial++; }
    exint        getMSSUpdateSerial() const { return myMSSUpdateSerial; }
    
    void         getRecommendedTextureLimit(RE_Render *r,
                                            int &max2d, int &max3d) const;
private:    
    // data:
    
    GR_DisplayOption    *myDisplaySet[GUI_NUM_DISPLAY_SETS];
    GUI_DisplaySetType   myDisplaySetMap[GUI_NUM_DISPLAY_SETS];
    GR_CommonDispOption  myCommonOptions;       // global to viewport

    float                myImageMinUV[2];
    float                myImageMaxUV[2];

    fpreal               myOriginGnomonSize;
    fpreal               myFloatingGnomonSize;
    int                  myHandleHighlightSize;

    static float         theHandleScale;

    HeadlightParms       myHeadlightParms;
    DomelightParms       myDomelightParms;
    PhysicalSkyParms     myPhysicalSkyParms;
    ThreePointParms      myThreePointParms;
    bool                 myUseHeadlight = false;
    bool                 myHeadlightHQ = false;
    bool                 myHeadlightDirty = true;
    HeadlightType        myHeadlightType = HEADLIGHT;
    UT_Color             myDefaultDiffuse;
    UT_Color             myDefaultSpecular;
    UT_Color             myDefaultEmission;
    UT_Color             myDefaultAmbient;
    fpreal               myDefaultRough;
    fpreal               myDefaultSpecRough;
    bool                 myDefaultMaterialDirty;

    DefaultMaterialType  myDefaultMatType;
    UT_StringHolder      myDefaultMatCapFile;
    fpreal               myDefaultMatCapIntensity;
    bool                 myDefaultMatCapDirty;

    fpreal               myXRayWireStrength;

    struct
    {
        UT_UniquePtr<GUI_RotoscopeData>
                                 myRotoscopeData;
        float                    myImageOffset[2]       = {0.0f, 0.0f};
        float                    myImageScale[2]        = {1.0f, 1.0f};
        float                    myOpacity              = 1.0f;
        float                    myBrightness           = 1.0f;
        bool                     myAutoPlaceImage       = false;
        ImageFitMode             myImageFitMode         = ImageFitMode::SCALE;
        bool                     myEnvMapImage          = false;
    } myRotoViews[GUI_NUM_ROTO_VIEWS];

    UT_StringHolder      myFGImage;
    UT_StringHolder      myFGDepthPlane;
    FGDepthStyle         myFGDepthStyle;
    fpreal               myFGOpacity;

    unsigned             mySelectMask;          // mask of entities the user
                                                // wants to select. Not saved.
    struct
    {
        unsigned
            showSelected        :1,
            showNonSelected     :1,
            showTemplates       :1,
            showFootprints      :1,
            showCurrentOutput   :1,
            showDisplay         :1,
            showGuides          :1,
            showObjectNames     :1,
            showFullNames       :1,
            drawOrigin          :1,
            drawStickyOrigin    :1,
            drawViewPivot       :1,
            drawWalls           :1, // draw bounding walls
            drawXYPlane         :1, // draw XY reference plane
            drawXZPlane         :1, // draw XZ reference plane
            drawYZPlane         :1, // draw YZ reference plane
            drawFieldGuide      :1,
            drawSafeArea        :1,
            drawBackgrounds     :1, // draw background images
            drawEnvironmentMaps :1,
            drawFilteredBackgrounds:1, // filter background in UV viewport.
            drawVertexAttrib2D  :1, // use vertex attribute
            autoDetectAttribType2D:1, // automatically track the attribute type 
            drawSpecular        :1, // specular highlights
            showIKCriticalZones :1, // inverse kin. danger zones
            drawCameraMask      :1,
            drawBadges          :1, // show viewport status badges
            drawXRay            :1, // allow draw of xray objs
            xrayQuality         :1, // fast/quality xray draw
            drawObjOrigins      :1, // allow draw of obj axes
            applySelectMask     :1, // select mask drives specific decorations
            useOverrides        :1, // Apply material overrides
            mssEnable           :1, // Apply material stylesheets
            mssPacked           :1, // Eval material stylesheets for packed geo
            mssPerPrim          :1, // per-prim material stylesheet eval
            dofEnable           :1, // Depth of field
            uniformFogEnable    :1, // Fog (uniform)
            volumeFogEnable     :1, // Fog (volumetric)
            bloom               :1, // Light bloom
            showForegroundImage :1, // FG Image
            useForegroundDepth  :1, // Use FG Image depth plane if present
            myFastHQIntLight    :1; // Lower samples in HQ Lighting/interaction
            
    } myFlags;
    
    struct
    {
            unsigned     isObjectLevel          :1; // Is this an object view?
    } myNoSaveFlags;

    // whether shading mode change is enabled/disabled
    bool                 myMoveModeOn;
    int                  myObjectMaterialLimit;

    gui_StereoPass       myStereoPass;
    UI_Value             myObjectLevelNotify;
    bool                 myLoadedDefaults;
    exint                myMSSUpdateSerial;
    gui_MatAssignMode    myMatAssignMode;
    bool                 myMatUpdate;
    bool                 myForLopsView;

    int                  myHQLightLimit;
    int                  myLightSampleLimit;
    int                  myShadowMapMemMB;
    fpreal               myShadowMapGenTime;
    
    UT_IntArray          mySceneOptions;
    UT_Vector2i          myFixedImageRes;
    UT_Vector2i          myCurrentImageRes;
    fpreal               myImageResFraction;
    bool                 myUseFixedImageRes;
    bool                 myUseViewportRes;
    bool                 myCameraCropMask;
    mutable bool            myPhysicalSkyFileDirty = true;
    mutable UT_StringHolder myPhysicalSkyFile;

    class FogParms
    {
    public:
        FogParms() : myFogColor(1.0,1.0,1.0), myFogDensity(1.0),
                     myFogOpacity(1.0), myFogStart(0.0), myFogEnd(1000.0),
                     myFogHeightMode(0), myFogHeight(100.0),
                     myFogIntensity(1.0), myFogFalloff(10.0)
            {}
        UT_Vector3F          myFogColor;
        fpreal               myFogDensity;
        fpreal               myFogOpacity;
        fpreal               myFogStart;
        fpreal               myFogEnd;
        int                  myFogHeightMode; 
        fpreal               myFogHeight; 
        fpreal               myFogIntensity;
        fpreal               myFogFalloff;
    };
    FogParms             myUniformFog;
    fpreal               myUniformFogClipDistance;
    bool                 myUniformFogUseClip = true;
    bool                 myUniformFogUseSun;
    fpreal               myUniformFogSunBloom;

    FogParms             myVolumeFog;
    int                  myVolumeFogQuality;
    fpreal               myVolumeFogScatterPara;
    fpreal               myVolumeFogScatterPerp;
    UT_StringHolder      myFogNode;

    fpreal               myBloomScale; 
    fpreal               myBloomIntensity; 
    fpreal               myBloomThreshold; 

    DOFBokeh             myDOFBokeh;
    UT_StringHolder      myDOFTex;
    fpreal               myDOFBokehAspect;
    fpreal               myDOFBokehBoost;

    UT_StringHolder      myUVMapFile;
    fpreal               myUVMapScale;
    GR_RenderVersion     myRenderType;
};

#endif