GUI_DetailLook.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_DetailLook.h ( GUI Library, C++)
 *
 * COMMENTS:
 *      A detail look encapsulates all of the data necessary to render a
 *      geometry in a viewport.
 *
 *      The name is a holdover from when it was derived from UI_Rectangle.
 */

#ifndef __GUI_DetailLook__
#define __GUI_DetailLook__

#include "GUI_API.h"
#include <UT/UT_Assert.h>
#include <UT/UT_BoundingBox.h>
#include <UT/UT_BoundingSphere.h>
#include <UT/UT_Color.h>
#include <UT/UT_IntrusivePtr.h>
#include <UT/UT_Map.h>
#include <UT/UT_Matrix4.h>
#include <UT/UT_PerfMonAutoEvent.h>
#include <UT/UT_PerfMonTypes.h>
#include <UT/UT_String.h>
#include <UT/UT_StringHolder.h>
#include <UT/UT_UniquePtr.h>
#include <UI/UI_Value.h>
#include <GEO/GEO_PackedTypes.h>
#include <GU/GU_Detail.h>
#include <GU/GU_DetailHandle.h>
#include <OP/OP_Network.h>
#include <RE/RE_RenderContext.h>
#include <GR/GR_DisplayOption.h>
#include <GR/GR_Light.h>
#include <BM/BM_State.h>
#include "GUI_DisplayOption.h"
#include "GUI_RenderCommon.h"
#include "GUI_VisInterface.h"
#include "GUI_GroupData.h"
#include "GUI_GUSelectionProxyHandle.h"

#include <utility>

class RE_Render;
class RE_Light;
class RE_Material;
class RE_Geometry;
class PXL_Raster;
class SIM_Data;
class SIM_RootData;
class GUI_GeoRender;
class GU_Detail;
class GU_ConstDetailHandle;
class gui_Instance;
class gui_GeoInstanceInfo;
class GUI_VisInterface;

typedef UT_IntrusivePtr<GUI_DetailLook> GUI_DetailLookPtr;

class GUI_API GUI_DetailLook : public BM_DetailLook
{
public:
    // This determines if the detail passed to setDetailHandle() is refenced or
    // copied to a new detail within this look.
    enum SetDetailMode
    {
        COPY_DETAIL,
        REFERENCE_DETAIL
    };

            GUI_DetailLook(GU_DetailHandle *gh = NULL,
                           const char *detail_name = NULL,
                           SetDetailMode mode = REFERENCE_DETAIL);

    void        incref()
                {
                    myRefCount.add(1);
                }
    void        decref()
                {
                    myRefCount.add(-1);
                    UT_ASSERT(myRefCount.relaxedLoad() >= 0);
                    if (myRefCount.relaxedLoad() == 0)
                        delete this;
                }

    virtual const char  *className() const;

    virtual bool        isDopGuide() const { return false; }
    virtual bool        needsOverlayRender() { return false; } 

    const char         *getName() const { return myDetailName; }
    void                setName(const char *name);

    void                setInitialized() { myInitializedFlag = true; }
    bool                isInitialized() const { return myInitializedFlag; }

    // Find out which node our gdp represents, if any:
    OP_Node     *getObject() const;             // inline, below
    OP_Node     *getSop() const;                // inline, below
    OP_Node     *getShopsRelativeTo() const;    // inline, below
    int          getVisualizedNodeId() const;   // inline, below

    // Set to new object/sop pair. returns true if the object or sop was
    // actually changed.
    bool         setObject(OP_Node *node);
    bool         setSop(OP_Node *node);

    // New Viewport codepaths

    // setupForRender() can be called in parallel. setup() methods are expected
    // to do non-GL work, such as convexing, surfacing, point normal computation
    virtual GUI_SetupResult setupForRender(
                                const GUI_DisplayOption &opts,
                                bool show_selections,
                                GR_DecorationOverride selmask_dec,
                                GR_DecorationOverride &sel_dec);

    // This is a stripped down version of setupForRender() when the viewer is
    // showing more than 1 viewport. The first viewport rendered does a full
    // setupForRender(), and subsequent viewports do fastSetupForRender(), since
    // many things do not change.
    bool                fastSetupForRender(GUI_DisplayOption &opts);

    // updateForRender() is called in serial. It does all the GL updating based
    // on the precomputed results in setup().
    void                updateForRender(
                                RE_RenderContext  r,
                                GUI_DisplayOption &opts,
                                GR_LightList *lights,
                                GR_DecorationOverride selmask_dec,
                                const char *view_name,
                                const GR_FrustumList &view_frustums,
                                bool &needs_alpha,
                                bool normal_update,
                                GR_UpdateReason additional_reasons);
    
    void                updateForRenderInit(
                                RE_RenderContext  r,
                                GUI_DisplayOption &opts,
                                GR_LightList *lights,
                                GR_DecorationOverride selmask_dec,
                                const char *view_name,
                                const GR_FrustumList &view_frustums,
                                bool &needs_alpha,
                                bool normal_update,
                                GR_UpdateReason additional_reasons);


    // updatePrimitivesForRender() is called in parallel for VK, serial
    // for GL. It does updates the GR_Primitive objects based on the
    // results of precomputed results in setup().
    void                updateForRenderParallel(
                                RE_RenderContext  r,
                                GUI_DisplayOption &opts,
                                GR_LightList *lights,
                                GR_DecorationOverride selmask_dec,
                                const char *view_name,
                                const GR_FrustumList &view_frustums,
                                bool &needs_alpha,
                                bool normal_update,
                                GR_UpdateReason additional_reasons);

    virtual void        cleanupAfterRender(RE_RenderContext r);

    // An update is still pending on this look's geoemtry.
    void                updatePending(bool up) { myUpdatePending = up; }
    bool                isUpdatePending() const { return myUpdatePending; } 

    // The serial part of update is finished, threaded update is still pending
    void                threadedUpdatePending(bool up) { myThreadedUpdatePending = up; }
    bool                isThreadedUpdatePending() const { return myThreadedUpdatePending; } 

    // Materials still need updating on this look (textures).
    void                materialUpdatePending(bool up)
                         { myMatUpdatePending = up; }
    bool                isMaterialUpdatePending() const
                         { return myMatUpdatePending; } 

    // called when this look is no longer displayed, but kept around for a short
    // time in case it might be displayed in the future
    void                retire();
    bool                isRetired() const { return myRetiredFlag; };
    void                reactivateRetired();

    // called when temporarily hidden, such as as display flag off.
    void                hide();

    // appends the contained geometry objects to 'geos'.
    void                getGeometryRenders(
                                UT_Array<GUI_GeoRender*> &geos,
                                GR_LightingPass p = GR_LIGHTING_ANY,
                                int geo_index = -1);
    void                setSingleGeometryRender(OP_Node *node);
    void                resetGeometryRender();

    // Set selection data to be displayed with this geometry.
    const UT_Array<GUI_GroupDataHandle> &getSelectData(int geo_index) const;
    void                addSelectData(GUI_GroupDataHandle select_data,
                                      int geo_index);
    void                clearSelectData();
    bool                hasSelectData() const;

    // This method determines whether this detail look should be rendered
    // for picking.  It only checks if it is potentially pickable, but does
    // not check if it currently being drawn. This only refers to the component
    // level picking present in SOPs. For object picking, check the isPickable()
    // flag on the getObject() node.
    virtual bool        isPickable() const;

    // Allows for custom pick priorities. 0 is normal, <0 low, >0 higher.
    virtual bool hasPickPriority() const { return false; }
    virtual bool getPickPriority(const GR_PickRecord &pick,
                                 int & /*priority*/) const { return false; }

    // This method checks if this detail look is even rendered given the
    // specified display options.
    virtual bool        isVisible(const GUI_DisplayOption &dopt) const;

    // Returns true if any of the contained details are lit.
    bool                areAnyLit() const
                            { return drawLit() && !isWireframeOnly(); }

    // returns true if any of the contained details are unlit.
    bool                areAnyUnlit() const { return myHasUnlitGeometry; }

    // returns true if any of the contained details have transparency.
    bool                hasTransparency() const;

    // returns true if any of the materials are reflective.
    bool                hasReflectiveMaterial() const;
    
    // returns a bitfield of decorations supported by all the GR_Primitives in
    // this look.
    int64               getPrimDecorMask() const { return myDecorMask; }

    // This look will not free the detail, it is up to the user
    int                          setDetailHandle(GU_DetailHandle handle);
    virtual int                  getNumDetailHandles() const; // inlined below
    virtual GU_DetailHandle      getDetailHandle(int i) const;
    virtual UT_Matrix4D          getDetailXform(int i) const;
    virtual void                 appendDOPDataName(UT_String &str, int i,
                                        bool descriptive) const;
    virtual const SIM_Data      *getDOPData(int i) const;
    virtual const SIM_RootData  *getDOPRootData(int i) const;
    virtual bool                 getIsDetailTempSelected(int i) const;
    // Get world space position
    virtual UT_Vector4F          getDetailPosition(int i) const;
    virtual void                 getDetailName(UT_String &name, int i) const;
    virtual void                 getDetailPath(UT_String &path, int i) const;
    virtual void                 getDetailDescriptiveName(UT_String &name,
                                                          int i) const;
    virtual void                 getDetailDescriptivePath(UT_String &path,
                                        int i) const;
    void                         signalNodeSelectionChanged(int i) const;

    virtual void                 setTempComponentSelection(
                                        int i, GUI_GUSelectionProxyHandle h);
    virtual GU_SelectionHandle   getTempComponentSelection(int i) const;

    virtual void                 releaseAllTempComponentSelections();

    void                         setEnableDOPDisplay(bool enable)
                                 { myEnableDOPDisplay = enable; }
    bool                         getEnableDOPDisplay() const
                                 { return myEnableDOPDisplay; }
    void                         setIsChosenDopnet(bool ischosen)
                                 { myIsChosenDopnet = ischosen; }
    bool                         getIsChosenDopnet() const
                                 { return myIsChosenDopnet; }

    bool                         hasUserSelection() const;

    void                 useNewLightInterface(bool i)
                                 { myUseNewLightInterface=i;}
    bool                 useNewLightInterface() const
                                 { return myUseNewLightInterface; }
    void                 addObjLight(int obj_light_id);
    bool                 hasObjLight(int obj_light_id) const;
    void                 removeObjLight(int obj_light_id);
    void                 clearObjLights();
    const UT_Set<int> &  activeObjLights() const { return myActiveLights; }

    // v Old light interface
    void                 setLightArray(RE_Light *lights[], int nLights = 0);

    void                 setGlobalLightArray(const UT_ValArray<RE_Light *> &lts,
                                             bool headlight);
    void                 removeLight(RE_Light *light);
    void                 enableAllLights();

    int                  getNumLights() const { return myLights.entries(); }
    RE_Light            *getLight(int i) const { return myLights(i); }
    const UT_ValArray<RE_Light *> &getLights() const { return myLights; }
    const UT_ValArray<RE_Light *> &getEnabledLights() const
                                               { return myEnabledLights; }
    // ^ end old light interface

    static RE_Light     *getGlobalHeadlight(bool for_solaris=false);
    static RE_Light     *getGlobalDomelight();

    void                 setUseWireColor(int c);
    void                 setWireColor(const UT_Color &clr);
    void                 setOutlineColor(const UT_Vector4F &clr);

    // The id passed in here may be either a node id or a "guide" id set by
    // the OP3D_GuideList on each piece of guide geometry.
    virtual UT_Color     getWireColor(int id) const
                         { return myWireColor; }

    UT_Vector4F          getOutlineColor() const
                         { return myOutlineColor; }

    // Methods to manage the view matrix, the user may use any of the
    // UT_Matrix4 methods to transform the matrix.
    void                 setXform(const UT_Matrix4D &mat)
                         { myXform = mat; myXformDirty = true; }
    UT_Matrix4D          getXform() const
                         { return isObjSolo() ? (myXform*mySoloXform) :myXform; }
    void                 setPivot(const UT_Vector3F &pivot)
                         { myPivot = pivot; }

    void                 setAllowShadingOpenCurves(bool val);
    bool                 shadeOpenCurves() const
                                { return myFlag.shade_open_curves; }
    
    void                 setDisplayAsSubdiv(bool val);

    // Methods to handle the look of the detail drawn.
    void                 copyFlagsFrom(const GUI_DetailLookPtr &look);
    
    virtual void setDetailDisplay(bool display)
                            {
                                if(!myFlag.overrideDisplay)
                                {
                                    if(myFlag.display != display)
                                        myDisplaySetDirty= true;
                                    myFlag.display = display;
                                }
                            }

    void        setGeometry(bool enable) { myFlag.isGeometry = enable; }
    void        setShowAxes(bool show_axes) { myFlag.showAxes = show_axes; }
    void        setPicking(bool picking)
                            { myFlag.shouldPick  = picking; }

    void        setRender(bool render)  { myFlag.render    = render; }
    void        setTemplate(bool templated)
                    {
                            if(myFlag.templated!=templated)
                                myDisplaySetDirty=true;
                            myFlag.templated    = templated;
                    }
    void        setFootprint(bool footprint)
                    { if(myFlag.footprinted!=footprint)
                            myDisplaySetDirty=true;
                      myFlag.footprinted = footprint; }
    void        setHighlight(bool highlight)
                    { myDisplaySetDirty |= (myFlag.highlighted != highlight);
                      myFlag.highlighted = highlight; }
    void        setXray(bool xray)
                    { myFlag.xray          = xray; }
    void        setTargetOutput(bool target_output)
                    {   if(myFlag.targetoutput !=target_output)
                            myDisplaySetDirty=true;
                        myFlag.targetoutput = target_output; }
    void        setCurrentOutput(bool current_output);
    void        setDrawLit(int onoff); // it's a bit more complicated now
    void        setDrawCookComponentSelection(bool enable);
    void        setSnappable(int onoff) { myFlag.snappable   = onoff; }
    void        setSecondarySelection(int onoff);
    void        setObjSelection(bool obj_sel);
    void        setObjCurrent(bool obj_current);
    void        setObjSelectionHint(bool obj_sel_hint);
    virtual void        setObjGhost(bool obj_ghost, OP_Node *for_node);
    void        setObjHidden(bool hide) { myFlag.objHide = hide; }
    void        setObjSolo(bool solo, const UT_Matrix4D *solo_transform=nullptr);
    void        setObjOutput(bool output) { myFlag.objOutput = output; }
    void        setOutputIndex(int index) { myOutputIndex = index; }
    void        setObjTypeMask(unsigned mask) { myObjTypeMask = mask; }
    void        setWireframeOnly(bool wireframe_only)
                    { myFlag.wireframeOnly = wireframe_only; }
    void        setOutline(bool outline)
                    { myFlag.outline = outline; }
    void        setSeparateOutline(bool b)
                    { myFlag.separateOutline = b; }
    void        setBeautyRender(bool b)
                    { myFlag.beautyRender = b; }
    void        setActiveModel(bool active_model)
                    {
                        if(myFlag.active_model != active_model)
                        {
                            myDisplaySetDirty = true;
                            myFlag.active_model = active_model;
                        }
                    }
    // Is a DM_Drawable look
    void        setIsDrawableLook(bool dr) { myDrawableFlag = dr; }
    bool        isDrawableLook() const { return myDrawableFlag; }

    void        setIsControlLook(bool c) { myFlag.isControlLook = c; }
    bool        isControlLook() const { return myFlag.isControlLook; }

    static void setUVObject(OP_Node *object);
    bool        isUVObject() const;

    void        setOnionSkinning(int onion_skin_state);
    bool        isOnionSkinning() const { return myFlag.onion_skin; }
    bool        isOnionSkinDeformation() const { return myFlag.onion_skin_deform;}
    
    void        onionSkinRender(RE_RenderContext r, GUI_DisplayOption &disp_opt,
                                int nsamples);


    // Frustum culling is enabled by default.
    void        useFrustumCulling(bool frust_cull)
                        { myFlag.use_frustum_culling = frust_cull; }
    bool        usesFrustumCulling() const
                        { return myFlag.use_frustum_culling && !myFlag.onion_skin
                                && !myLastPointInstanceState &&
                                getUsesGeoRenderInstancing(); }

    virtual void applyBundleToDisplayedObjects( OP_Bundle *bdl, int object_vis_change_count);

    // The following methods allow the user to set the display flag while
    // caching the old value, and resetting it back later.
    virtual void setDisplaySavingPrevValue(int onoff)
                {
                    myFlag.prevDisplay = myFlag.display;
                    myFlag.display = onoff;
                    myFlag.overrideDisplay = true;
                }

    virtual void resetOverrideUsingSavedValue()
                {
                    myFlag.display = myFlag.prevDisplay;
                    myFlag.overrideDisplay = false;
                }

    // this is not the underlying node's display flag state.
    bool        isDetailDisplayOn() const; // inlined below
    // just the display state alone; use the above for almost everything.
    bool        getDetailDisplay() const { return myFlag.display; }
    
    bool        getShowAxes() const     { return myFlag.showAxes; }
    bool        isGeometry() const      { return myFlag.isGeometry; }
    bool        isSymbolicGeometry() const { return myFlag.isSymGeo; }
    bool        isPickingOn() const     { return myFlag.shouldPick; }
    bool        isRenderOn() const      { return myFlag.render; }
    bool        isTemplated() const     { return myFlag.templated; }
    bool        isFootprinted() const   { return myFlag.footprinted; }
    bool        isHighlighted() const   { return myFlag.highlighted; }
    virtual bool isXray() const         { return myFlag.xray || myFlag.geoxray || myIsXRay; }
    bool        isTargetOutput() const  { return myFlag.targetoutput; }
    bool        isCurrentOutput() const { return myFlag.currentoutput; }
    virtual bool isGuide() const        { return false; }
    virtual bool useWireColor(int node_id) const { return myFlag.usewireclr; }
    bool        drawLit() const         { return myFlag.drawLit; }
    bool        displayAsSubdiv()       { return myFlag.displayAsSubdiv; }
    bool        drawCookComponentSelection() const
                            { return myFlag.drawCookComponentSelection; }
    bool        isSnappable() const     { return myFlag.snappable; }
    bool        isSecondarySelection() const { return myFlag.secondarySelection; }
    bool        isObjSelection() const  { return myFlag.objSelection; }
    bool        isObjCurrent() const    { return myFlag.objCurrent; }
    bool        isObjSelectionHint() const { return myFlag.objSelectionHint; }
    bool        isObjGhost() const  { return myFlag.objGhost; }
    bool        isObjHidden() const { return myFlag.objHide; }
    bool        isObjSolo() const   { return myFlag.objSolo; }
    bool        isObjOutput() const   { return myFlag.objOutput; }
    int         getOutputIndex() { return myOutputIndex; }
    unsigned    getObjTypeMask() const { return myObjTypeMask; }
    bool        isWireframeOnly() const { return myFlag.wireframeOnly; }
    bool        isOutline() const { return myFlag.outline; }
    bool        isSeparateOutline() const { return myFlag.separateOutline; }
    bool        isBeautyRender() const { return myFlag.beautyRender; }
    bool        isActiveModel() const { return myFlag.active_model; }
    bool        isPointInstanced() const { return myHasPointInstancing; }
    bool        hasInstanceFile() const { return myHasInstanceFile; }
    bool        useInstancerObjTransform() const
                                        { return myInstanceUseTransform; }

    bool        needsAlphaPass() const
                    { return myFlag.needsAlphaPass; }
    void        setNeedsAlphaPass(bool e)
                    { myFlag.needsAlphaPass = e; }

    // Flag as a deleted look, so that it can be deleted rather than cached.
    void        setIsDeleted() { myFlag.being_deleted = true; }
    bool        isDeleted() { return myFlag.being_deleted; }

    // Weak flag that affects only GUI_DetailLook::isVisible()
    bool        forceHidden() const { return myFlag.forceHidden; }
    void        setForceHidden(bool on)
                    {
                        if(myFlag.forceHidden != on)
                        {
                            myDisplaySetDirty= true;
                            myFlag.forceHidden = on;
                        }
                    }

    // If true, this flag forces GUI_DetailLook to be a UVObject.
    bool        forceAsUVObject() const 
    { 
        return myFlag.forceAsUVObject; 
    }
    void        setForceAsUVObject(bool on)
    {
        myFlag.forceAsUVObject = on; 
    }

    bool        castShadows() const { return myFlag.castShadows; }
    void        setCastShadows(bool on)
                    {
                        if(myFlag.castShadows != on)
                        {
                            myDisplaySetDirty= true;
                            myFlag.castShadows = on;
                        }
                    }

    // Set information about which geometry groups to color.
    const UT_StringHolder       &showGroupMask() const;
    void                         setShowGroupMask(const UT_StringHolder &mask);
    GA_GroupType                 showGroupType() const;
    void                         setShowGroupType(GA_GroupType group_type);
    int                          showGroupColorVersion() const;
    void                         setShowGroupColorVersion(int version);

    int                          getBoundingBox2D(UT_BoundingBox &bbox,
                                        const char *name,
                                        int use_vertex) const;
    int                          getBoundingBox3D(UT_BoundingBox &bbox,
                                        const UT_Matrix3R *rot) const;

    void                         updateBBox();
    void                         invalidateBBox();
    const UT_BoundingBox        &worldBBox();

    // Viewport type mask (PERSP, TOP, UV, etc)
    void                         setViewportMask(unsigned mask) 
                                 { myViewportMask = mask; }
    unsigned int                 getViewportMask() const
                                 { return myViewportMask; }

    // Per-Viewport display. ID is the viewport's unique ID.
    bool                         shownInViewport(int viewport_id) const;
    void                         showInViewport(int viewport_id);
    void                         showInAllViewports();

    static void setGlobalViewSerial(GUI_DisplayOption &disp,
                                    int serial, int serial2, int id)
                {
                    disp.common().setViewSerialNum(serial, serial2, id);
                }

    // return the display set that this object belongs to.
    GUI_DisplaySetType   getDisplaySetType() const
                         {
                             if(!myDisplaySetDirty)
                                 return myDisplaySet;
                             return privGetDisplaySetType();
                         }

    GUI_DisplaySetType   updateDisplaySetType()
                         { return privGetDisplaySetType(); }


    void                renderObjectName(RE_RenderContext r,
                                         GUI_DisplayOption *dispopt);
    virtual void        renderOrQueueObjectAxes(UT_Vector3FArray &axes,
                                                UT_Vector3FArray &pivots);
    static void         renderQueuedObjectAxes(RE_RenderContext r,
                                               GUI_DisplayOption *dispopt,
                                               const UT_Vector3FArray &axes,
                                               const UT_Vector3FArray &pivots);

    // The global chosen dopnet is set to filter out the drawing of geometry
    // flagged as originating from this dopnet.
    static void          setGlobalChosenDopnet(OP_Node *dopnet)
    {
        if( dopnet )
        {
            UT_WorkBuffer       path;
            dopnet->getFullPath(path);
            ourChosenDopnetPath = path;
        }
        else
        {
            ourChosenDopnetPath.clear();
        }
    }
    static const char   *getGlobalChosenDopnetPath()
    {
        return ourChosenDopnetPath.c_str();
    }

    static bool          matchesChosenDopnetPath(const char *path)
    {
        auto len = ourChosenDopnetPath.length();
        return len
            && !strncmp(ourChosenDopnetPath, path, len)
            && (path[len] == ':' || path[len] == '\0');
    }

    // Used to assign a temporary ID to the look.
    void                 setLookID(int id) { myID = id; }
    int                  getLookID() const { return myID; }

    // Get/Set the object's viewport LOD
    GEO_ViewportLOD      getObjectLOD() const   { return myObjectLOD; }
    void                 setObjectLOD(GEO_ViewportLOD lod)
                            { myObjectLOD = lod; }

    void                 useObjectMaterials(bool use_obj_mat);
    bool                 getAssignedMaterials(UT_Array<OP_Node *> &nodes) const;

    void                 setShowMaterials(bool show)
                         { myFlag.showMaterials = show; }
    bool                 showMaterials() const
                         { return myFlag.showMaterials; }

    // Override the default material for this look (otherwise the material is
    // taken from GUI_MaterialManager::getFactoryMaterial()).
    void                 setFactoryMaterialOverride(RE_MaterialPtr material)
                            { myFactoryMaterialGL = material; }
    void                 setFactoryMaterialOverride(GR_MaterialPtr material)
                            { myFactoryMaterial = material; }
    RE_MaterialPtr       getFactoryMaterialGL(bool lit, bool draw_uv);
    bool                 hasFactoryMaterialOverride()
                            { return myFactoryMaterialGL || myFactoryMaterial; }
    RE_MaterialPtr       getFactoryMaterialOverrideGL()
                            { return myFactoryMaterialGL; }
    GR_MaterialPtr       getFactoryMaterialOverride()
                            { return myFactoryMaterial; }

    GR_MaterialPtr       getFactoryMaterial(bool lit, bool draw_uv);
    virtual bool         isTimeDependent(fpreal t);
            bool         areInstancesTimeDependent(fpreal t);
    virtual int64        getVersion();
    void                 bumpVersion() { myLookVersion++; }

    /// @{
    /// Flag the look as time-dependent, even if its source node is not (e.g.
    /// APEX character scenes). This is reset on each update.
    bool                 forceTimeDependent() const { return myFlag.forceTimeDep; }
    void                 setForceTimeDependent(bool v) { myFlag.forceTimeDep = v; }
    /// @}

    // The name of the actively rendering or updating viewport
    static void          setActiveViewport(const char *name, int id);
    // viewname (persp1)
    static const char   *getActiveViewport();
    // viepwort unique id
    static int           getActiveViewportId();
     // viewname/Material setup
    static const char   *getActiveViewportMatString();

    
    static void          visibleViewportTypes(bool view_3d, bool view_2d);
    static bool          hasVisible3D();
    static bool          hasVisibleUV();

    static void          visibleUVAttribs(UT_StringArray &attribs);
    static const UT_StringArray &visibleUVAttribs();
    static int64         visibleUVAttribSerial();

    enum { VIEW_3D = 0x1, VIEW_2D = 0x2 }; // for the masks
    static void          visibleViewportBoundaries(
                                bool bound_3d,
                                UT_StringArray &bound_3d_uvs,
                                UT_Array<std::pair<UT_StringHolder,int> > &uvs);
    static bool          hasVisibleBoundaries();
    static bool          visible3DBoundary();
    static const UT_StringArray &visible3DBoundariesInUV();
    // uv name, view mask
    static const UT_Array<std::pair<UT_StringHolder, int>>
                        &visibleUVBoundaries();

    const UT_IntArray   &getActiveVisualizers() const
                            { return myActiveVisualizers; }
    int                  numActiveVisualizers() const
                            { return myActiveVisualizers.entries(); }
    void                 appendActiveVisualizer(int vis_id)
                            { myActiveVisualizers.append(vis_id);
                              myCollectVisPrimitives.append(0); }
    void                 clearActiveVisualizers()
                            {
                                myActiveVisualizers.clear();
                                myCollectVisPrimitives.clear();
                            }
    GR_Primitive        *getCollectVisPrimitive(int i)
                            { return myCollectVisPrimitives(i); }
    void                 setCollectVisPrimitive(int i, GR_Primitive *prim)
                            { myCollectVisPrimitives(i) = prim; }

    void                 requireErrorCheck() { myFlag.errorsChecked = false; }
    void                 checkForErrors();
    int64                getNodeErrorID() const { return myOpErrorPosted; }

    void                 setRedrawValue(UI_Value *redraw)
                            { myRedrawValue = redraw; }
    void                 requestRedraw()
                            { if(myRedrawValue) myRedrawValue->changed(NULL); }

    void                 resetVisualizerCheck()
                         {
                             myFlag.visualizerCheck = true;
                             myFlag.needVisualizerSetup = false;
                         }
    void                 needVisualizerSetup(bool setup)
                         {
                             myFlag.visualizerCheck = false;
                             myFlag.needVisualizerSetup = setup;
                         }
    bool                 runVisualizerSetup() const
                         {
                             return (myFlag.needVisualizerSetup ||
                                     myFlag.visualizerCheck);
                         }

    virtual const PXL_Raster *getImage(RE_Render *)
                         { return nullptr; }
    DEP_MicroNode       *contextMicroNode()
                         { return myContextMicroNode.get(); }
    void setContextMicroNode(UT_UniquePtr<DEP_MicroNode> &&micronode)
                         { myContextMicroNode = std::move(micronode); }

    // Wrapper class to avoid sprintf's when not recording
    class PerfMonAutoMatEvent : public UT_PerfMonAutoEvent
    {
    public:
        PerfMonAutoMatEvent(const GUI_DetailLook &look)
        {
            // Early exit if we're not recording
            UT_Performance *perf = UTgetPerformance();
            bool record_viewport = perf->isRecordingViewportStats();
            bool record_memory = perf->isRecordingMemoryStats();
            if (!record_viewport && !record_memory)
                return;
            
            const char *
                viewport_name = GUI_DetailLook::getActiveViewportMatString();
            const char *
                look_name = look.getName();

            if (record_viewport)
            {
                setTimedEventId_(
                    perf->startTimedViewportDrawEvent(
                        viewport_name, look_name, UT_PERFMON_3D_VIEWPORT));
            }
                    
            if (record_memory)
            {
                setMemoryEventId_(
                    perf->startMemoryViewportDrawEvent(
                        viewport_name, look_name, UT_PERFMON_3D_VIEWPORT));
            }
        }
    };

protected:
    ~GUI_DetailLook() override;

    void                 cacheNodePtrs();

    // Multi-object instancing
    void                 initInstanceTable();
    GUI_GeoRender       *addInstance(GU_ConstDetailHandle cgdh,
                                     const char *name,
                                     const UT_Matrix4D &xform,
                                     int64 version,
                                     int instance_index,
                                     int object_id,
                                     int inst_object_id,
                                     bool is_guide,
                                     bool time_dep);
    void                 finalizeInstanceTable();

    using gui_CachedInstGeo = std::pair<GUI_GeoRender *, bool>;

    bool                 createObjectInstance(const char *instance_path,
                                int64 base_version,
                                fpreal t,
                                gui_Instance &instance,
                                OBJ_Node *instancer,
                                UT_StringMap<gui_CachedInstGeo> &existing,
                                bool rel_to_sop);
    void                 markGeoForRemoval(GUI_GeoRender *gr);
    void                 removeDeletedGeos();
    int64                computeInstanceVersion(const GU_Detail *dtl);

    // Indicates whether instancing should be implemented using the
    // GUI_GeoRender instancing capabilities. If false, GUI_GeoRenderShared
    // objects are used to instance the geometry without true OGL instancing.
    virtual bool         getUsesGeoRenderInstancing() const
                         { return true; }

    // End multi-object instancing
    GUI_SetupResult      setupAllGeos(const GUI_DisplayOption &disp_opt,
                                bool show_selections,
                                GR_DecorationOverride selmask_dec,
                                GR_DecorationOverride &sel_dec);

    virtual GUI_GeoRender *getOrCreateGeometryRender(int index);

    void                 setXRayOverride(bool xray) { myIsXRay = xray; }

    UT_Array<GUI_GeoRender *>                    myGeoRender;
    UT_Array<GUI_GeoRender *>                    myStashedGeoRenderShared;
    UT_Array<GUI_SetupResult>                    mySetupResults;
    UT_Map<int, UT_Array<GUI_GroupDataHandle> >  mySelectData;

    UT_Array<GUI_GeoRender *>                    myOnionSkinRenders;
    UT_Array<GUI_SetupResult>                    myOnionSkinSetupResults;
    
private:

    void         generateObjectName(RE_RenderContext  r,
                                    GUI_DisplayOption *dispopt,
                                    UT_String name,
                                    int geo_index,
                                    GR_DecorFontSize fontsize,
                                    RE_Geometry &geo);
    bool         setupPointInstancing(bool show_selections,
                                      GR_DecorationOverride selmask_dec,
                                      GR_DecorationOverride &select_dec,
                                      fpreal instance_fract,
                                      int limit);
    GUI_DisplaySetType   privGetDisplaySetType() const;

    void                 updateInstancingStatus();
    GUI_GeoRender *      createGeoRender(int index,const char *opt_suffix=NULL);
    void                 checkGeoRenders();

    GUI_GeoRender       *checkForDetailCaching(GUI_GeoRender *geo);
    void                 freeCachedDetails();
    void                 freeDeletedCachedDetails();

    int                  getNumOnionSkins() const;
    const GU_DetailHandle &getOnionSkinDetail(int index) const;
    GUI_SetupResult      processSkins(const GUI_DisplayOption &dopt);
    void                 addOnionSkin(OBJ_Node *obj, SOP_Node *sop,
                                      fpreal skin_t, fpreal geo_t,
                                      bool deforming,
                                      bool is_pre_frame);
    void                 clearOnionSkins();

    class GUI_DetailLookFlags
    {
    public:
        GUI_DetailLookFlags()
        {
            showAxes            = false;
            render              = true;
            isGeometry          = true;
            isSymGeo            = false;
            shouldPick          = true;
            display             = true;
            templated           = false;
            footprinted         = false;
            highlighted         = false;
            xray                = false;
            geoxray             = false;
            targetoutput        = false;
            currentoutput       = false;
            usewireclr          = false;
            drawLit             = true;
            drawCookComponentSelection = true;
            needsAlphaPass      = false;
            snappable           = true;
            secondarySelection  = false;
            objSelection        = false;
            objCurrent          = false;
            objSelectionHint    = false;
            objGhost            = false;
            wireframeOnly       = false;
            outline             = false;
            separateOutline     = false;
            beautyRender        = true;
            prevDisplay         = true;
            prevShouldPick      = true;
            overrideDisplay     = false;
            displayAsSubdiv     = false;
            shaders_used        = false;
            active_model        = false;
            being_deleted       = false;
            shade_open_curves   = false;
            onion_skin          = false;
            onion_skin_deform   = false;
            use_frustum_culling = true;
            errorsChecked       = false;
            visualizerCheck     = false;
            needVisualizerSetup = true;
            forceHidden         = false;
            forceAsUVObject     = false;
            showMaterials       = true;
            castShadows         = true;
            objHide             = false;
            objSolo             = false;
            objOutput           = false;
            isControlLook       = false;
            forceTimeDep        = false;
        }

        bool      showAxes:1,           // draw the axes of the detail
                isGeometry:1,           // renderable
                  isSymGeo:1,           // symbolic geo only (no materials)
                    render:1,           // render the detail
                shouldPick:1,
                   display:1,           // display the detail
                 templated:1,
               footprinted:1,
               highlighted:1,           // Node has the highlight flag set
                      xray:1,           // display wireframe within other geo
                   geoxray:1,           // Xray drawing enabled by an attribute on the geometry.
              targetoutput:1,           // display sop when in view current
                                        // mode
             currentoutput:1,           // current sop when in view current
                                        // mode and the display flag is on a
                                        // different sop.
                usewireclr:1,           // Override default wire color
                   drawLit:1,           // In shaded mode, draw shaded
drawCookComponentSelection:1,           // Draw the GU cook component selection
            needsAlphaPass:1,           // requires a second pass
                 snappable:1,           // is the detail snappable
        secondarySelection:1,           // Draw a secondary selection
              objSelection:1,           // object selection
                objCurrent:1,           // object current flag
          objSelectionHint:1,           // hint that object makes good selection
                  objGhost:1,           // ghosted object
             wireframeOnly:1,           // draw in wireframe only
                   outline:1,           // draw the outline
           separateOutline:1,           // draw the outline separately in a separate pass
              beautyRender:1,           // wether or not to draw in beauty mode
               prevDisplay:1,           // cached value of the previous value of the display flag.
               prevShouldPick:1,        // cached value of the previous value of the pick flag.
           overrideDisplay:1,           // don't allow changes to the display
           displayAsSubdiv:1,           // draw as subdivision.
              shaders_used:1,           // Shaders have been used on the object
              active_model:1,           // Use SOP-level display sets
             being_deleted:1,           // We are in the process of deletion
         shade_open_curves:1,           // Open curves are light-shaded
                onion_skin:1,           // Draw faded images before/after
         onion_skin_deform:1,           // Use deformation onion skinning
       use_frustum_culling:1,           // Frustum culling is allowed
             errorsChecked:1,           // Errors checked after cook
           visualizerCheck:1,           // Check for visualizer setup
       needVisualizerSetup:1,           // Requires visualizer setup
               forceHidden:1,           // Force Hidden flag
           forceAsUVObject:1,           // Force the look to be a uv object.
             showMaterials:1,           // Display look with materials
               castShadows:1,           // The look can cast shadows
                   objSolo:1,           // object is solo (hidden obj mode)
                   objHide:1,           // Object is temporarily hidden (^)
                 objOutput:1,           // output SOP of an Object
             isControlLook:1,           // Look represents a control
              forceTimeDep:1;           // Force look to be time-dependent
    };
    GUI_DetailLookFlags  myFlag;

    UT_StringHolder      myShowGroupMask;
    GA_GroupType         myShowGroupType;
    int                  myShowGroupColorVersion;
    GU_DetailHandle      myDetailHandle;
    UT_Vector4I          myDetailVersion;
    GUI_GUSelectionProxyHandle   myTempComponentSelection;
    UT_Array<GU_DetailHandle> myOnionSkinDetails;

    // Override the wireframe display color.
    UT_Color             myWireColor;

    // Override the outline color.
    // UT_Vector4F instead of UT_Color since we want RGBA,
    // and UT_Color only supports RGB.
    UT_Vector4F          myOutlineColor;

    int                  myObjectID;
    int                  mySopID;
    int                  myOutputIndex;
    unsigned             myObjTypeMask;
    OP_Node             *myCachedObject;
    OP_Node             *myCachedSop;
    UT_String            myDetailName;
    int                  myID;
    GEO_ViewportLOD      myObjectLOD;
    bool                 myIsXRay;
    bool                 myIsOnionSkin;
    UT_String            myInstanceObjectRef;

    bool                 myUseNewLightInterface;
    UT_Set<int>          myActiveLights;
    
    UT_ValArray<RE_Light *> myLights;
    UT_ValArray<RE_Light *> myEnabledLights;

    unsigned int         myViewportMask;
    bool                 myEnableDOPDisplay;
    bool                 myIsChosenDopnet;
    bool                 myNullDetailFlag;
    bool                 myRetiredFlag;
    bool                 myInitializedFlag;
    bool                 myCopyDetailFlag;
    bool                 myDrawableFlag;

    mutable bool                 myDisplaySetDirty;
    mutable GUI_DisplaySetType   myDisplaySet;    

    fpreal               myPrevInstanceFract;
    int                  myPrevInstanceLimit;
    int                  myInstanceFractSerial;
    int64                myPointInstanceVersion;
    int                  myInstanceXformVersion;
    fpreal               myInstanceTime;
    int                  myInstanceObjectID;
    bool                 myHasInstancing;
    bool                 myHasPointInstancing;
    bool                 myInstanceUseTransform;
    bool                 myHasTransparentPrimitives;
    bool                 myLastPointInstanceState;
    bool                 myHasInstanceFile;
    bool                 myXformDirty;
    bool                 myDetailDirty;
    UT_Matrix4D          myXform;
    UT_Matrix4D          mySoloXform;
    UT_Vector3F          myPivot;
    int64                myOpErrorPosted;
    int64                myLookVersion;

    // Variable geometry Instancing
    UT_Map<int, gui_GeoInstanceInfo *> myDetailTable;
    int                  myGeoCountId;
    const GU_Detail     *myTempLastDetail;
    GUI_GeoRender       *myTempLastGeo;

    // Cached details for cached playback (ie cache SOP)
    UT_Map<exint, GUI_GeoRender *> myCachedDetailTable; 
    bool                 myCachingDetails;
    int64                myCacheSopID;
    int64                myCacheSopSerial;

    bool                 myHasUnlitGeometry;
    int64                myDecorMask;
    bool                 myUpdatePending; 
    bool                 myMatUpdatePending;
    bool                 myThreadedUpdatePending;
    RE_MaterialPtr       myFactoryMaterialGL;
    GR_MaterialPtr       myFactoryMaterial;

    exint                myVisUpdateTime;       // last visualization-triggered
                                                // update time (visualization
                                                // clock measurement)
    exint                myVisUpdateVersion;    // version at the time of last
                                                // visualization-triggered
                                                // update

    UT_IntArray          myActiveVisualizers;   // unique ids of visualizers
                                                // currently active for look

    UT_Array<GR_Primitive *>
                         myCollectVisPrimitives;

    UT_Array<GUI_GeoRender *> myGeosToRemove;

    UT_BoundingBox       myWorldBBox;
    UT_UniquePtr<UT_Set<int> > myViewportVisibility;
    UT_UniquePtr<DEP_MicroNode> myContextMicroNode;

    class gui_OnionSkinDetail
    {
    public:
        gui_OnionSkinDetail(const GU_DetailHandle &dh)
            : myDetail(dh), myRender(NULL), myUsedFlag(true)
            {
                myDetail.addPreserveRequest();
            }
        ~gui_OnionSkinDetail();
              
        GU_DetailHandle myDetail;
        GUI_GeoRender  *myRender;
        bool            myUsedFlag;
    };
    typedef std::pair<exint,int64> gui_OnionSkinId;
    typedef UT_Map<gui_OnionSkinId, gui_OnionSkinDetail *> gui_OnionSkins;
    gui_OnionSkins myOnionSkins;

    class gui_OnionSkinLayer
    {
    public:
        gui_OnionSkinLayer(gui_OnionSkinId id, fpreal t, const UT_Matrix4D &mat, bool pre)
            : myDetailID(id), myTime(t), myRender(NULL),
              myTransform(mat), myIsPreFrame(pre) {}

        gui_OnionSkinId myDetailID;
        fpreal         myTime;
        GUI_GeoRender *myRender;
        UT_Matrix4D    myTransform;
        bool           myIsPreFrame;
    };
    UT_Array<gui_OnionSkinLayer *> myOnionSkinLayers;

    class CachedDetailPos {
    public:
        CachedDetailPos()
            : myPos(0,0,0,1)
            , myCacheCount(-1)
            , myUniqueId(-1)
        {}

        CachedDetailPos(const GU_Detail *detail)
        {
            myCacheCount = detail ? detail->getMetaCacheCount() : -1;
            myUniqueId = detail ? detail->getUniqueId() : -1;
        }

        void computePosition(const GU_Detail *detail)
        {
            if(detail)
            {
                UT_BoundingBox bbox;
                detail->getBBox(bbox, UT_Matrix4R::getIdentityMatrix());
                
                UT_Vector3 point3 = bbox.center();
                myPos = UT_Vector4F(point3.x(), point3.y(), point3.z(), 1.0);
            }
        }

        bool operator==(const CachedDetailPos& p)
        {
            return myCacheCount == p.myCacheCount
                && myUniqueId   == p.myUniqueId;
        }

        const UT_Vector4F& position() { return myPos; }

    private:
        UT_Vector4F myPos;
        int         myCacheCount;
        int         myUniqueId;
    };
    // mutable because these are cached positions
    mutable UT_ValArray<CachedDetailPos> myDetailPositions;

    static UT_StringHolder      ourChosenDopnetPath;

    UI_Value                    *myRedrawValue;
    SYS_AtomicInt32              myRefCount;
};

static inline void intrusive_ptr_add_ref(GUI_DetailLook *d) { d->incref(); }
static inline void intrusive_ptr_release(GUI_DetailLook *d) { d->decref(); }

inline int
GUI_DetailLook::getNumDetailHandles() const
{
    return myNullDetailFlag ? 0 : 1;
}

inline OP_Node *
GUI_DetailLook::getObject() const
{
    if(myCachedObject)
        return myCachedObject;
    if(myObjectID != OP_INVALID_NODE_ID)
        return OP_Node::lookupNode(myObjectID);
    return NULL;
}

inline OP_Node *
GUI_DetailLook::getSop() const
{
    if(myCachedSop)
        return myCachedSop;
    if(mySopID != OP_INVALID_NODE_ID)
        return OP_Node::lookupNode(mySopID);
    return NULL;
}

inline OP_Node *
GUI_DetailLook::getShopsRelativeTo() const
{
    OP_Node *node = getObject();
    if(!node)
    {
        node = getSop();
        if(node)
            return node->getCreator();
    }
    return node;
}

inline int
GUI_DetailLook::getVisualizedNodeId() const
{
    if (getDisplaySetType() >= GUI_DISPLAY_MODEL)
        return mySopID;
    else
        return myObjectID;
}

inline bool
GUI_DetailLook::isDetailDisplayOn() const
{
    if((myFlag.display || myFlag.objOutput) && !myFlag.objHide)
    {
#if UT_ASSERT_LEVEL > 2
        if((myObjectID == OP_INVALID_NODE_ID || OP_Node::lookupNode(myObjectID))
           && (mySopID == OP_INVALID_NODE_ID || OP_Node::lookupNode(mySopID)))
            return true;
        UT_ASSERT_MSG(!"Stale GUI_DetailLook: ", myDetailName);
#else
        return true;
#endif
    }
    return false;
}

inline void
GUI_DetailLook::setObjSolo(bool solo, const UT_Matrix4D *solo_transform)
{
    if(myFlag.objSolo != solo)
    {
        myFlag.objSolo = solo;
        if(solo && solo_transform)
            mySoloXform = *solo_transform;
        else
            mySoloXform.identity();
        myXformDirty = true;
    }
}


// UTformat support.
GUI_API size_t format(char *buffer, size_t buffer_size, const GUI_DetailLook &v);


#endif