GUI_GeoRender.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_GeoRender.h ( GUI Library, C++)
 *
 * COMMENTS:
 *      General rendering class for a GU_Detail.
 */
#ifndef GUI_GeoRender_h
#define GUI_GeoRender_h

#include <UT/UT_BoundingBox.h>
#include <UT/UT_Lock.h>
#include <UT/UT_Optional.h>
#include <UT/UT_Rect.h>
#include <UT/UT_Set.h>
#include <UT/UT_String.h>
#include <UT/UT_StringMap.h>
#include <UT/UT_StopWatch.h>
#include <UT/UT_Matrix4.h>
#include <UT/UT_ValArray.h>
#include <UT/UT_UniquePtr.h>
#include <UT/UT_Array.h>
#include <DEP/DEP_MicroNode.h>
#include <RE/RE_Types.h>
#include <RE/RE_Texture.h>
#include <RE/RE_TimerQuery.h>
#include <RE/RE_ContextSpecificTable.h>
#include <RE/RE_RenderContext.h>
#include <GA/GA_Attribute.h>
#include <GR/GR_Defines.h>
#include <GR/GR_Material.h>
#include <GR/GR_RenderInfo.h>
#include <GT/GT_Primitive.h>
#include <GU/GU_DetailHandle.h>
#include <GU/GU_SelectType.h>
#include "GUI_GroupData.h"
#include "GUI_RenderCommon.h"
#include "GUI_DisplayOption.h"
#include "GUI_DetailLook.h"
#include "GUI_PrimitiveHook.h"
#include "GUI_RenderCommon.h"
#include "GUI_API.h"
#ifdef USE_VULKAN
class RV_Geometry;
class RV_ShaderBlock;
class RV_ShaderVariableSet;
#endif

class GA_EdgeGroup;
class GA_ElementGroup;
class GU_Detail;
class GEO_PrimClassifier;
class GEO_DetachedHedgeInterface;
class RE_Render;
class RE_Geometry;
class GR_LightList;
class RE_ReflectMap;
class RE_Shader;
class RE_VertexArray;
class RE_ElementArray;
class GUI_DetailLook;
class GA_ROAttributeRef;
class GA_PointGroup;
class GA_EdgeGroup;
class GA_PrimitiveGroup;
class GA_AIFSharedStringTuple;
class GEO_Primitive;
class GR_DisplayOption;
class GR_CommonDispOption;
class gui_AttribInfo;
class gui_CollectionPrim;
class GR_Primitive;
class GR_SelectionAdapter;
class GT_PrimCharacterScene;
class GT_RefineParms;
class OBJ_Node;
class gui_HookedPrims;
class gr_PrimEntry;
class GR_VisualizerInfo;
class gui_RenderHookEntry;
class gui_UpdateResults;
class GUI_ObjectMaterialCache;
class GR_Uniforms;

using GUI_PrimTypeKey = std::pair<GA_PrimitiveTypeId, GT_PrimitiveType>;

class GUI_API GUI_GeoRender
{
public:
                        GUI_GeoRender(GUI_DetailLook *look,
                                      const char *name,
                                      int geo_index,
                                      int name_index);
    virtual            ~GUI_GeoRender();

    virtual const char *className() const { return "GUI_GeoRender"; }

    virtual bool        isLopRender() const { return false; }
    
    void                setGeometry(OP_Node *node);
    OP_Node            *getGeometry() const;

    // set the base geometry name for the cache name.
    void                setGeoName(const char *name);
    // set the cache name to exactly 'name'. Only used for instancing.
    void                setInstanceName(const char *name);

    const char         *getCacheName() const { return myCacheName; }

    // the index of the detail within the GUI_DetailLook.
    void                setGeoIndex(int idx) { myGeoIndex = idx; }
    int                 getGeoIndex() const { return myGeoIndex; }
    void                setNameIndex(int idx) { myNameIndex = idx; }
    int                 getNameIndex() const { return myNameIndex; }

    // If this represents a node, this will return its node id.
    int                 getNodeID() const { return myNodeID; }

    // If this represents some guide geometry, the index within a list of
    // guides is tracked through these methods.
    void                setGuideID(int id) { myGuideID = id; }
    int                 getGuideID() const { return myGuideID; }

    // The geometry this object will be rendering.
    void                setDetailHandle(const GU_ConstDetailHandle &handle);
    virtual GU_ConstDetailHandle &getDetailHandle() { return myDetailHandle; }

    // control the display of the GUI_GeoRender object. Those not displayed
    // cannot be rendered or picked.
    void                setDisplayed(bool is_disp) { myIsDisplayed = is_disp; }
    bool                isDisplayed() const { return myIsDisplayed; }

    // local transform of the object
    bool                setDetailTransform(const UT_DMatrix4 &xform);
    const UT_DMatrix4  &getDetailTransform(int index) const;
    const UT_DMatrix4  &getDetailInvTransform(int index) const;
    int                 getNumDetailTransforms() const
                        { return myDetailTransforms.entries(); }
    void                setDetailFullTransform(const UT_DMatrix4 &xform)
                        { myDetailFullTransform = xform; }
    const UT_DMatrix4  &getDetailFullTransform() const
                        { return myDetailFullTransform; }

    // For an instance object, this is the instance object's transform. The
    // detail transforms are the individual point transforms.
    void                setInstancerTransform(const UT_DMatrix4 &xform)
                            { myInstancerTransform = xform;
                                myInstancerIdentityFlag = xform.isIdentity(); }
    void                setInstancerTransformIdentity()
                            { myInstancerTransform.identity();
                                myInstancerIdentityFlag = true; }
    const UT_DMatrix4  &getInstancerTransform() const
                            { return myInstancerTransform; }
    
    const UT_BoundingBox &localBBox();
    const UT_BoundingBox &worldBBox();

    bool                 updateBBox();


    // bounding box of this object
    virtual int         getBoundingBox2D(UT_BoundingBox &bbox,
                                const char *name,
                                int use_vertex) const;
    virtual int         getBoundingBox3D(UT_BoundingBox &bbox,
                                const UT_Matrix3R *rot) const;

    int                 getInstancedBoundingBox3D(UT_BoundingBox &bbox,
                                const UT_Matrix3R *rot,
                                const UT_DMatrix4 &detail_xform) const;

    // set the view * projection matrix
    static void         setWorldToScreen(const UT_Matrix4R &xform);

    // instanced transforms for the object, when point instancing
    void                setIsInstancedGeo(bool instanced);
    bool                addInstanceTransform(const UT_DMatrix4 &xform,
                                             int geo_index);
    void                clearInstanceTransforms();
    void                setInstanceVersion(int64 version);
    int64               getInstanceVersion() const;

    /// Query the memory used by the prims in this geometry
    void                gpuMemoryUsage(exint &used_bytes,
                                       exint &cached_bytes,
                                       exint &pinned_bytes);

    // setup() called before any update or drawing is done, and cleanup() is
    // called when all rendering is complete for the current redraw.
    virtual GUI_SetupResult setup(const GUI_DisplayOption &disp_opt,
                                  GUI_DisplaySetType state,
                                  bool show_selection,
                                  GR_DecorationOverride selmask_dec,
                                  GR_DecorationOverride &select_dec,
                                  bool &needs_alpha,
                                  bool is_current);

    // minimal setup for multiple viewports (such as a quad config). One
    // viewport is called with setup(), the others fastSetup(). 
    virtual bool        fastSetup(const GUI_DisplayOption &disp_opt);
    
    virtual void        update(RE_RenderContext r,
                               GR_DisplayOption *opt,
                               GUI_SetupResult setup_reason,
                               GR_DecorationOverride selmask_dec,
                               const char *view_name,
                               bool &needs_alpha,
                               const GR_FrustumList &view_frustums);

    // Update run in parallel, during Vulkan Update. Only called
    // if look is marked as needing parallel update in serial update
    // and `hasParallelUpdate` returns true
    virtual void        updateParallel(RE_RenderContext r,
                               GR_DisplayOption *opt,
                               GUI_SetupResult setup_reason,
                               GR_DecorationOverride selmask_dec,
                               const char *view_name,
                               bool &needs_alpha,
                               const GR_FrustumList &view_frustums);
    virtual bool        hasParallelUpdate() const;

    void                updateRenderVersion(RE_RenderContext r);

    virtual void        cleanup(RE_RenderContext r);

    bool                isSetup() const { return mySetupFlag; }
    bool                needsAlphaPass() const { return myNeedsAlphaPassFlag; }
    void                needsAlphaPass(bool need) { myNeedsAlphaPassFlag=need;}

    bool                hasPendingMaterialTextures() const
                        { return myMaterialTexturePending; }

    void                addMaterialReference(OP_Node *mat_node);
    void                removeMaterialReference(OP_Node *mat_node);
    void                clearMaterialReferences();

    // called when this look is no longer displayed and placed in a short cache
    // in case it is displayed again.
    void                retire();

    // Called when an object isn't displayed anymore, aka retire()-lite.
    void                hide();

    // Return true if gl_lit is set on the contained detail.
    bool                isLit() const { return myLitFlag; }

    // return true if this geo has guide rendering
    bool                hasGuideParts() const { return myHasGuideParts; }

    // Return if gl_wireframe is set to a positive value.
    bool                forceWireframe() const { return myWireframeFlag; }

    // Return if gl_wireframe is set to a negative value.
    bool                forceShaded() const { return myForceShadedFlag; }

    // Return if gl_xray is set to a positive value.
    bool                forceXRay() const { return myXRayFlag; }

    // Return true if should be drawn shaded in the beauty pass 
    // with current settings, false if it should be drawn wireframe
    bool                shouldDrawShaded(GUI_DisplayOption &disp_opt) const;

    // The post-pass ID is used to setup and render post-render passes
    void                setPostPassID(int id) { myPostPassID = id ; }
    int                 getPostPassID() const { return myPostPassID; }

    // An additional deferred pass is required (not a post pass).
    bool                needsDeferredPass() const { return myNeedsDeferredPass;}
    void                setNeedsDeferredPass(bool need)
                        { myNeedsDeferredPass = need;}
    void                setDeferredPass(bool dpass) { myIsDeferPass = dpass; }
    bool                isDeferredPass() const { return myIsDeferPass; }
    
    // An additional parallel primary pass is required (not a post pass).
    bool                needsParallelPass() const { return myNeedsParallelPass;}

    // Returns the time in seconds of various operations 
    fpreal              getSetupTime() const { return fpreal(mySetupTime)*1e-9;}
    fpreal              getDrawTime() const  { return fpreal(myDrawTime)*1e-9;}

    virtual bool        isObjectRender() const { return false; }

    bool                hasMaterialReflection() const
                        { return myMaterialHasReflection; }

    void                setGhosted(bool ghost)
                        { myInfo.myObjectGhosted = ghost; }
    void                setObjectSelection(int obj_selection)
                        { myInfo.myObjectSelection = obj_selection; }
    void                setCanRenderUV(int uv_render)
                        { myInfo.myCanRenderUV = uv_render; }
    bool                canRenderUV() const
                        { 
                            return myInfo.myCanRenderUV;
                        }

    bool                getComponentSelection(
                                const GR_DisplayOption *opt,
                                GR_SelectionAdapter &adapter) const;

    // DRAWING --------------------------------------------------------------
    
    // wire representation of all objects.
    virtual void        wireframeRender(RE_RenderContext r,
                                        GUI_DisplayOption &disp_opt,
                                        GR_RenderMode mode,
                                        GR_RenderFlags render_flags);
    
    // Beauty pass shaded render.
    virtual GUI_RenderPassFlags
                        beautyRender(RE_RenderContext r,
                                     GUI_DisplayOption &disp_opt,
                                     GR_ShadingPass shade_pass,
                                     GR_AlphaPass  alphapass,
                                     GR_RenderMode mode,
                                     GR_RenderFlags render_flags);
    
    static void         setupRender(RE_RenderContext r, GR_RenderMode mode);
    static void         cleanupRender(RE_RenderContext r, GR_RenderMode mode);

    void                 setupGhosting(RE_RenderContext r,
                                       const GUI_DisplayOption &disp_opt,
                                       UT_Vector4F &ghost_color,
                                       fpreal ghost_amount = 0.5);
    void                 cleanupGhosting(RE_RenderContext r);
    
    // Various simple rendering, such as matte or depth.
    virtual void        utilityRender(RE_RenderContext r,
                                      GUI_DisplayOption &disp_opt,
                                      GR_RenderMode mode,
                                      GR_RenderFlags rflags);

    // rendering for post-render passes that primitives request.
    virtual void        postPassRender(RE_RenderContext r,
                                       GUI_DisplayOption &disp_opt,
                                       GR_AlphaPass apass);

    // Object bounding box render
    virtual void        bboxRender(RE_RenderContext r,
                                   GUI_DisplayOption &disp_opt,
                                   GR_RenderMode render_mode);

    // Render any highlights required
    void                renderMatteHighlights(RE_RenderContext r,
                                              GUI_DisplayOption &disp_opt,
                                              GR_RenderFlags render_flags);
    // Render onion skins
    void                onionSkinRender(RE_RenderContext r,
                                        GUI_DisplayOption &disp_opt);

    virtual int64       getPrimDecorationMask() const
                        { return myPrimDecorMask; }

    // Modelling aids, like normals or uv coord display.
    // This function is called before any specific decorations are rendered.
    virtual void        setupDecorationsRender(RE_RenderContext r);
    // This functions renders one type of decoration.
    virtual void        decorationRender(
                                RE_RenderContext r,
                                GUI_DisplayOption &disp_opt,
                                GR_Decoration dec,
                                GR_DecorVisibility vis,
                                bool override_dispopt,
                                GR_DecorRenderFlags render_flags);
    
    virtual void        customDecorationRender(RE_RenderContext r,
                                               GUI_DisplayOption &disp_opts,
                                               const GR_VisualizerInfo *dec,
                                               GR_DecorRenderFlags flags);

    // PICKING --------------------------------------------------------------

    // Return true if this object can be selected, and if 'node' isn't null,
    // assign to it the node that should be selected when this object is picked
    bool                canBeSelected(OP_Node *op,
                                      GUI_DisplayOption &disp_opt,
                                      bool pick_template,
                                      bool pick_non_sel,
                                      bool pick_ghost,
                                      OBJ_Node **node = nullptr) const;

    // A version of canBeSelected() used when every displayed detail is treated
    // as an "object".
    bool                canBeSelectedWhenNotUsingOps(
                                      GUI_DisplayOption &disp_opt,
                                      bool pick_template,
                                      bool pick_non_sel,
                                      bool pick_ghost) const;
    
    // Full object pick - all or nothing. 
    virtual void        objectPick(RE_RenderContext r,
                                   GUI_DisplayOption &opts,
                                   GR_RenderFlags render_flags,
                                   const GR_ObjectPickFlags &pick_flags,
                                   bool force_wire);

    // Component pick, component type based on display option.
    virtual int         componentPick(RE_RenderContext r,
                                      GUI_DisplayOption &opts,
                                      unsigned int primmask,
                                      GEO_PrimTypeCompat::TypeMask primask,
                                      GR_PickStyle pickstyle,
                                      bool has_pick_map,
                                      UT_Array<GR_PickRecord> *pick_records);

    GUI_DetailLook     &look() const { return *myLook; }
    const char         *name() const { return myCacheName; }

    // LIGHTING ------------------------------------------------------------
    
    void                setupLighting(GR_LightList *list, bool headlight);
    void                cleanupLighting();

    static void         resetStats();
    static void         getStats(int &num_objs,
                                 int &num_polys,
                                 int &num_vertices);
    
    void                bumpObjectMaterial() { myObjectMaterialDirty=true; }

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

    int                 getObjectMaterialID() const { return myObjMaterialID; }

    void                adoptAtlas(const RE_MaterialAtlas &gl_atlas,
                                   const GR_MaterialAtlas &vk_atlas);

    bool                isBBoxShadingMode(const GR_DisplayOption *opt) const
                        {
                            return opt->shadingMode()==GR_BOUNDING_BOX_WIRE
                                || opt->shadingMode()==GR_BOUNDING_BOX_SHADED;
                        }

    bool                isBBoxShadingMode(GUI_DisplayOption &opt) const
                        {
                            return isBBoxShadingMode(getDisplayOptionSet(opt));
                        }

    // Reflection map support, for this object
    bool                prepReflectionMap(RE_RenderContext r,
                                          GUI_DisplayOption &opt,
                                          int64 version,
                                          fpreal time);
    void                startReflectionPass(RE_RenderContext r,
                                            RE_TextureCubeFace f);
    void                endReflectionPass(RE_RenderContext r);
    void                finishReflectionMap(RE_RenderContext r,
                                            GUI_DisplayOption &opt);
    RE_Texture         *getReflectionMap() const;

    // VISUALIZERS -----------------------------------------------------------
    
    exint                getVisUpdateTime() const
                            { return myVisUpdateTime; }

    exint                getVisRefineTime() const
                            { return myVisRefineTime; }

    void                 refreshVisUpdateTime()
                            { myVisUpdateTime =
                                GUI_VisInterface::getHandler()->bumpClock(); }

    void                 refreshVisRefineTime()
                            { myVisRefineTime = myVisUpdateTime =
                                GUI_VisInterface::getHandler()->bumpClock(); }

    bool                 hasUpdateVisualizer(int vis_id) const
                            { return myUpdateVisualizers.find(vis_id) >= 0; }

    bool                 hasRefineVisualizer(int vis_id) const
                            { return myRefineVisualizers.find(vis_id) >= 0; }

    const UT_IntArray   &getActiveVisualizers() const
                            { return look().getActiveVisualizers(); }

    const UT_IntArray   &getUpdateVisualizers() const
                            { return myUpdateVisualizers; }

    const UT_IntArray   &getRefineVisualizers() const
                            { return myRefineVisualizers; }

    void                 refreshUpdateVisualizers()
                            { myUpdateVisualizers = getActiveVisualizers(); }

    void                 clearUpdateVisualizers()
                            { myUpdateVisualizers.clear(); }

    void                 refreshRefineVisualizers()
                            { myRefineVisualizers = getActiveVisualizers(); }

    void                 clearRefineVisualizers()
                            { myRefineVisualizers.clear(); }

    void                 runCreatorVisualizers(int &listcount,
                                UT_Array<GT_PrimitiveHandle> &handles);

    GUI_VisFlags         getActiveVisFlags(int prim_idx,
                                GUI_VisContext context) const;

    // Look for an attribute in the given owner class (or all of them for
    // GT_OWNER_INVALID) in all cached GT_Primitives in the detail
    // (those used for updating GR_Primitives in the last update, which,
    // in particular, have been filtered by visualizes) and return
    // the first matching attribute if any.

    const
    GT_DataArrayHandle   findCachedAttribute(const char *attrib_name,
                                GT_Owner owner = GT_OWNER_INVALID) const;

    // Cached data used for display. Tied to the underlying GU_Detail.
    virtual const GEO_DetachedHedgeInterface    *getHedgeInterface(
                                                        bool use_hidden_grp);
    virtual const GEO_PrimClassifier    *getPrimClassifier(GU_Connectivity con);
    virtual const GA_EdgeGroup          *getHiddenEdgeGroup();
    virtual const GA_ElementGroup       *getVisibleElementGroup(GA_GroupType t);

    static int          getPolygonMeshLimit(RE_RenderContext r);
    static int          getPointMeshLimit(RE_RenderContext r);

    static void         handleMaterialChange(OP_Node *src, void *dest,
                                             OP_EventType type, void *data);

    bool                isMSSEnabled() const        { return myMSSEnable; }
    bool                isMSSPackedEnabled() const  { return myMSSPackedGeo; }
    bool                isMSSPerPrimEnabled() const { return myMSSPerPrim; }
    bool                areOverridesEnabled() const
                                { return myMaterialUseOverrides; }
    int                 getMaterialLimit() const { return myMaterialLimit; }
    void                setMaterialLimitExceeded(bool e)
                                { myMaterialLimitExceeded = e; }
    
    // clear all primitives and associated caching information
    void                invalidateGeo();

    // clear the cached data ids used to enable GR_PACK_TRANSORM_CHANGED
    // faster code path
    void                clearDataIds()
                                { myDataIds.clear(); }

#ifdef USE_VULKAN
    static bool initShaders(RV_Instance* inst);
    static void cleanupShaders();
#endif

    GR_MaterialAtlas *materials() { return &myVulkanMaterials; }

    bool              hasMaterialOpChanges() const
                          { return (myMatOpChanges.size()!=0); }

#ifdef USE_VULKAN
    // RAY TRACING ----------------------------------------------------------
    void        prepareForRayTrace(RE_RenderContext r, int tag, int light_id);
#endif
    
protected:
    
    virtual void         cleanupMaterials() {}

    void                 invalidateBounds()
                         {
                             myLocalBBox.makeInvalid();
                             myWorldBBox.makeInvalid();
                             myLook->invalidateBBox();
                         }
    virtual void         doUpdateBBox(UT_BoundingBox &world_bbox,
                                      UT_BoundingBox &local_bbox);

    void                 setShowMaterials(bool show) { myShowMaterials = show; }
    bool                 showMaterials() const       { return myShowMaterials; }
    virtual bool         shouldRender(const GU_Detail *geo) const;

    int                  getNumPrimitives() const
                            { return myPrimitives.entries(); }
    GR_Primitive        *getPrimitive(int index) const;

    GR_DisplayOption    *getDisplayOptionSet(GUI_DisplayOption &disp_opt)
                         { return &disp_opt[ look().getDisplaySetType() ]; }
     
    const GR_DisplayOption *getDisplayOptionSet(
                                    const GUI_DisplayOption &disp_opt) const
                         { return &disp_opt[ look().getDisplaySetType() ]; }
    
    // Required Render functions -------------------------------------------
    
    // Wireframe only.
    virtual void        wireRender(RE_RenderContext r,
                                GUI_DisplayOption &disp_opt,
                                const GU_Detail *geo,
                                GR_RenderMode mode,
                                GR_RenderFlags flags);

    // Solid polygon render
    virtual void        solidRender(RE_RenderContext r, 
                                GUI_DisplayOption &disp_opt,
                                const GU_Detail *geo,
                                GR_RenderMode mode,
                                GR_RenderFlags flags,
                                GR_AlphaPass pass) {};

    virtual void        simpleRender(RE_RenderContext r,
                                GUI_DisplayOption &opt,
                                const GU_Detail *geo,
                                GR_RenderMode mode,
                                GR_RenderFlags flags) {};

    virtual void        simpleBBoxRender(RE_RenderContext r,
                                GUI_DisplayOption &opt,
                                RE_Shader *shader=0,
                                bool fill=true,
                                bool outline=true) {};
    
    // Utility functions ---------------------------------------------------
    
    // Returns the decorations required for the selection types on this detail
    GR_DecorationOverride getSelectionDecorations(
                                const GR_DisplayOption *opt) const;

    // Returns true if the geometry has a selection which requires a closure
    // color.
    bool                 isClosureSelection(GU_SelectionHandle sel, 
                                bool &has_edges) const;
    bool                 isClosureSelection(GR_SelectionAdapter &sel,
                                bool &has_edges) const;

    // returns true if the buffer was filled because the attribute existed in
    // the detail, or false if a constant attribute was created (which must be
    // filled in)
    enum FetchBufResult
    {
        FETCH_NO_GEO_ATTRIB,
        FETCH_NO_SHADER_ATTRIB,
        FETCH_CACHED,
        FETCH_FILLED,
        FETCH_ERROR
    };

    // returns true if all materials were loaded (textures included).
    // can return false if timeout > 0 and it took too long.
    bool        prepMaterials(RE_RenderContext r, 
                              const GR_DisplayOption *opts,
                              bool &needs_alpha_pass);
    bool        prepVulkanMaterials(RV_Render *r,
                                   const GR_DisplayOption *disp,
                                    bool &needs_alpha);
    int         prepVulkanMaterialList(RV_Render *r,
                                       GR_MaterialAtlas &mats,
                                       const GR_DisplayOption *opts,
                                       UT_Set<int> &op_ids,
                                       bool &needs_alpha,
                                       bool &changed);

    // Setup wire selection uniforms on 'r', and modify 'flags' to include
    // GR_RENDER_FLAG_WIRE_OVER if needed.
    void        setupWireSelectParms(RE_RenderContext r,
                                     const GUI_DisplayOption &disp_opts,
                                     bool is_wireframe,
                                     GR_RenderFlags &flags);
    void        cleanupWireSelectParms(RE_RenderContext r);
    
    // Sets the object matrix uniform based on our instancer transform,
    // detail transform, etc.
    void        setObjectMatrixUniform(RE_RenderContext r);

    void        doPrimitiveUpdates(RE_RenderContext r,
                                  GR_DisplayOption *opts,
                                  UT_Array<GT_PrimitiveHandle>& handles,
                                  GT_RefineParms& refine_opts,
                                  GR_UpdateReason reason,
                                  GR_DecorationOverride req_dec,
                                  const char *view_name,
                                  const GR_FrustumList &view_frustums,
                                  bool did_refinement,
                                  bool prim_update,
                                  bool &needs_alpha);
    void        updatePrimitives(RE_RenderContext r,
                                 GR_DisplayOption *opts,
                                 UT_Array<GT_PrimitiveHandle> &hlist,
                                 GT_RefineParms &refine_opts,
                                 GR_UpdateReason reason,
                                 GR_DecorationOverride req_dec,
                                 const char *view_name,
                                 const GR_FrustumList &view_frustums);
    void        processPrimitives(const GU_ConstDetailHandle &geo,
                                  GT_PrimitiveHandle &ph,
                                  GT_RefineParms &refparms,
                                  int &listcount,
                                  const GR_DisplayOption &dispopt,
                                  GR_UpdateReason reason,
                                  const char *cache_name,
                                  UT_Array<GT_PrimitiveHandle> &handles);
    bool        processPrim(const GU_ConstDetailHandle &geo,
                            GT_PrimitiveHandle &ph,
                            GT_RefineParms &refparms,
                            int &listcount,
                            const GR_DisplayOption &dispopt,
                            GR_UpdateReason reason,
                            const char *cache_name,
                            UT_Array<GT_PrimitiveHandle> &handles,
                            bool apply_filter_vis,
                            int &packed_index);

    void        processAlembicArchive(GT_PrimitiveHandle &ph,
                                      const GU_ConstDetailHandle &gdh,
                                      GT_RefineParms &refparms,
                                      int &listcount,
                                      const GR_DisplayOption &dispopt,
                                      GR_UpdateReason reason,
                                      const char *cache_name,
                                      UT_Array<GT_PrimitiveHandle> &handles,
                                      exint mat_id);
    void        clearUnusedAlembicArchives();

    void        renderMatteGroupColors(RE_RenderContext r,
                                       GUI_GroupDataHandle group_data,
                                       const GR_DisplayOption *opt,
                                       GR_RenderFlags render_flags);

    // Lower level render function used by beautyRender, wireRender, etc.
    void        renderPrims(RE_RenderContext r,
                            const GR_DisplayOption *opt,
                            GR_RenderMode mode,
                            GR_RenderFlags flags,
                            GR_AlphaPass alphapass,
                            bool use_materials);
    
    bool        createOrReuseRefinedPrim(GT_PrimitiveHandle &ph,
                                         const GU_ConstDetailHandle &gdh,
                                         const GEO_Primitive *geo_prim,
                                         int &listcount,
                                         const GR_DisplayOption &disp,
                                         GR_UpdateReason reason,
                                         const GT_RefineParms &ref_parms,
                                         const char *cache_name,
                                         UT_Array<GT_PrimitiveHandle> &handles,
                                         bool processing_geo_prims,
                                         bool apply_filter_vis,
                                         int packed_index,
                                         int64 mat_id);
    GR_PrimAcceptResult checkForExistingPrim(GT_PrimitiveHandle &ph,
                                             GR_Primitive *prim,
                                             int           pindex,
                                             GR_UpdateReason     reason,
                                             const GT_RefineParms &ref_parms,
                                             const GU_ConstDetailHandle &gdh,
                                             const GEO_Primitive *geo_prim,
                                             int          &listcount,
                                             UT_Array<GT_PrimitiveHandle> &hdl,
                                             bool         processing_geo_prims,
                                             int          packed_index);

    void        classifyPrim(const GT_Primitive *prim);
    void        resetPrimClassify();

    void        accumulateTime(RE_RenderContext r);
    
    void        buildEdgeHighlight(RE_RenderContext r,
                                   const GU_Detail *geo,
                                   GR_UpdateReason reason,
                                   const GR_DisplayOption *opt,
                                   const char *view_name);

    bool                 buildInstanceSelection(bool has_sel_overrides);
    fpreal               getPointInstanceFraction(const GR_DisplayOption *opts) const;
    UT_Matrix4DArray    *getPointInstanceTransforms(const GR_DisplayOption *opts);

    RE_CacheVersion      getGeoVersion(const GU_Detail *geo,
                                       const GR_DisplayOption *opt);
    RE_CacheVersion      getSelectionVersion(const GU_Detail *geo,
                                             const GR_DisplayOption *opt);
    RE_CacheVersion      getEdgeHighlightVersion(const GU_Detail *geo,
                                                 const GR_DisplayOption *opt,
                                                 bool include_selection);
        
    void                setSelection(int64 id, int64 version)
                          { mySelectionId = id; mySelectionRevision = version; }

    GR_PrimAcceptResult  processHookPrimitive(GT_PrimitiveHandle &gt_prim,
                                              const GEO_Primitive *geo_prim,
                                              const GU_ConstDetailHandle &gdh,
                                              GR_UpdateReason    reason,
                                              const GT_RefineParms &ref_parms,
                                              const char *cache_name,
                                              GR_Primitive *&created,
                                              int &list_index,
                                              int &hook_priority,
                                              bool &filtered_prim,
                                              gui_RenderHookEntry *&prev,
                                              UT_Array<GT_PrimitiveHandle>&hdls,
                                              bool        processing_geo_prims,
                                              int                 packed_index);
    
    void                 processFilterHooks(GT_PrimitiveHandle  &gt_prim,
                                            const GEO_Primitive *geo_prim);

    void                 restartCollectionPrimitives();
    void                 removeUnusedCollectionPrimitives();

    void                 find3DBoundaries(const GU_Detail *geo,
                                          const GA_PrimitiveGroup *within_prims,
                                          GA_EdgeGroup *boundary_group);
    void                 findUVBoundaries(const GU_Detail *geo,
                                          const GA_PrimitiveGroup *within_prims,
                                          GA_EdgeGroup * uv_boundary_group,
                                          const GA_ROHandleV2 &uv,
                                          bool vert_uvs);
    
    class gui_BoundaryData
    {
    public:
        gui_BoundaryData()  : myUsed(false), myAttribVersion(-1)   {}
        
        int64                      myAttribVersion;
        UT_SharedPtr<GA_EdgeGroup> myEdges;
        UT_SharedPtr<RE_Geometry>  myGeo;
        UT_SharedPtr<RE_Geometry>  myGeoV;
        UT_SharedPtr<RE_Geometry>  my2DGeo;
        UT_SharedPtr<RE_Geometry>  my2DGeoV;
        bool                       myUsed;
    };

    bool                matchesVersion(gui_BoundaryData &bdata,
                                       const UT_StringHolder &attrib_name,
                                       const RE_CacheVersion &ver,
                                       bool view_3d, bool vert_uv);
    void                 createEdgeGeo(RE_RenderContext r,
                                       gui_BoundaryData &bdata,
                                       const GA_EdgeGroup *edges,
                                       bool is_3d,
                                       bool is_vertex,
                                       const UT_StringHolder &attrib_name,
                                       const UT_StringHolder &cache_suffix,
                                       const GU_Detail *geo,
                                       const RE_CacheVersion &ev,
                                       GA_ROHandleV2 *uvhandle = nullptr);
    
    GR_RenderInfo       &getRenderInfo()
                         { return myInfo; }

    void                getRefineParms(RE_RenderContext r,
                                       const GR_DisplayOption *opts,
                                       GT_RefineParms &p) const;

    void                 resizePrimArray(exint nprims, bool clear = false);
    void                 assignPrim(exint index,
                                    GR_Primitive *prim,
                                    const GT_PrimitiveHandle &gtprim);
    void                 updateWorldTransform();

    bool                 checkDisplacementChange(const GR_CommonDispOption &opt);
    
    static UT_Lock       theShaderLock;

    static int           theNumObjects;
    static int           theNumPolys;
    static int           theNumVertices;

    const GU_Detail     *myLockedDetail;
    RE_MaterialAtlas     myMaterialAtlas;
    GR_MaterialAtlas     myVulkanMaterials;
    GUI_ObjectMaterialCache *myObjectMaterialCache;
    UT_Map<UT_StringRef,int> myAttributes;
    UT_Map<UT_StringRef,int> myPrevAttributes;
    UT_UniquePtr<gui_UpdateResults> myUpdateResults;

    int64                myEdgePrimsVersion;
    UT_SharedPtr<GA_PrimitiveGroup> myEdgePrims;

    gui_BoundaryData     my3DBoundary;
    UT_StringMap<gui_BoundaryData> myUVBoundary;
    UT_StringMap<bool>   myUVAttribIsVertex;
    gui_BoundaryData     myEdgeSelection;
    bool                 myHasEdgeSelection;
    int64                myUVAttribSerial;
    
    int64                myInstanceVersion;
    int64                myLimitInstanceVersion;
    int                  myViewSerial;
    int                  myViewID;
    int                  myTexCacheSerial; 
    int                  myDefaultMatSerial; 

    GR_LightList        *myLightList;
    bool                 myUseHeadlight;
    int64                myPrimDecorMask;
    bool                 myCheckUpdateViewFlag;
#ifdef USE_VULKAN
    UT_UniquePtr<RV_Geometry>    myCubeGeo;
    UT_UniquePtr<RV_ShaderBlock> myCubeTransforms;
    UT_UniquePtr<RV_ShaderVariableSet> myCubeSet;
#endif

private:
    bool                shouldUVRender(const GU_Detail *geo,
                                       const GUI_DisplayOption &disp,
                                       bool is_vertex) const;
    bool                shouldRender(const GU_Detail *geo,
                                     const GUI_DisplayOption &disp,
                                     GR_RenderFlags render_flags) const;
    bool                shouldRender(const GU_Detail *geo,
                                     const GUI_DisplayOption &disp,
                                     GR_DecorRenderFlags decor_flags) const;
    bool                shouldRender(const GU_Detail *geo,
                                     const GUI_DisplayOption &disp,
                                     GR_PickStyle pick_style) const;
    
    bool                requiresStateChange(const GUI_DisplayOption &disp_opt,
                                            GUI_DisplaySetType newset,
                                            GUI_DisplaySetType oldset) const;
    
    GR_UpdateReason     checkForShaderUpdates(const GU_Detail *geo,
                                              const GUI_DisplayOption &disp);
    bool                prepObjectMaterial(RE_RenderContext r,
                                           const GR_DisplayOption &opts);
    bool                checkAutoVertexNormal(const GU_Detail *dtl,
                                              const GR_CommonDispOption &opts);

    bool                inPackedPrim() const
                            { return myPackedPrimLevel > 0; }
    bool                inInstancePrim() const
                            { return myInstancePrim.entries() > 0; }
    void                updateInstanceEntry(gr_PrimEntry *entry,
                                            int prim_index);

    bool                processInstancedPrims(const GT_PrimitiveHandle &ph,
                                              int &listcount,
                                              UT_Array<GT_PrimitiveHandle> &hdl,
                                              int64 geo_id, int64 geo_count,
                                              int packed_index,
                                              int64 mat_id);

    // instancing
    void                buildPointInstanceArray(RE_RenderContext r,
                                                const GR_DisplayOption *dopts,
                                                const GU_Detail *dtl,
                                                bool use_fraction_parm);
    void                pointInstanceGuideRender(RE_RenderContext r,
                                                 GUI_DisplayOption &disp_opt);
    void                renderEdgeHighlight(RE_RenderContext r,
                                            const GR_DisplayOption *op,
                                            GR_RenderFlags render_flags);
    void                renderBBox(RE_RenderContext r,
                                   GUI_DisplayOption &opt,
                                   bool set_shader = false,
                                   bool is_matte = false,
                                   bool fill=true,
                                   bool outline=true);
#ifdef USE_VULKAN
    virtual int         buildInstanceTransforms(RE_RenderContext r,
                                                RV_ShaderProgram *shader);
#endif
    OP_Node *           getObjectMaterial(fpreal t);
    void                clearMaterialInterests();
    
    UT_Array<gr_PrimEntry *>     myPrimitives;
    UT_IntArray                  myPrimitiveIndex;
    
    GUI_GroupDataHandle          myGroupData;

    UT_Array<gui_HookedPrims *>  myHookedGEOPrims;

    bool                         myObjectMaterialDirty;
    int                          myTopObjectID;
    int                          myShaderNodeID;
    UT_StopWatch                 myShaderRetryTimer; 
    int                          myNodeID;
    int                          myGuideID;
    bool                         myUseObjectMaterial;
        
    GR_RenderInfo                myInfo;
    GUI_DetailLook              *myLook;
    int                          myGeoIndex;
    int                          myNameIndex;
    UT_String                    myCacheName;
    bool                         mySetupFlag;
    bool                         myHasGLStateCheckPrims;
    bool                         myLitFlag;
    bool                         myShadeOpenCurvesFlag;
    bool                         myShadeOpenCurvesFlagSet;
    bool                         myHasGuideParts;
    bool                         myHasPackedPrims;
    bool                         myHasPackedFragments;
    bool                         myHasPackedInstances;
    bool                         myWireframeFlag;
    bool                         myForceShadedFlag;
    bool                         myXRayFlag;
    bool                         myRecordingTime;
    bool                         myIsDisplayed;
    bool                         myIsSubD = false;
    
    bool                         myHasAgentPrims;
    bool                         myAgentLastLODEnable;
    int                          myAgentLastMinPoints;
    int                          myAgentLastMaxLOD;

    UT_Optional<fpreal>          myCharacterSceneTime;
    UT_Array<UT_IntrusivePtr<GT_PrimCharacterScene>> myCharacterScenes;
    
    bool                         myHasPolygons;
    bool                         myHasCurves;
    bool                         myHasPoints;

    RE_ContextSpecificTable<RE_TimerQuery> myDrawStartTime;
    RE_ContextSpecificTable<RE_TimerQuery> myDrawEndTime;
    int                          myDrawTimeWaiting;
    int64                        myDrawTime;
    int64                        mySetupTime;

    int                          myDetailID;
    int64                        myVersion;
    int64                        myTopologyVersion;
    int                          myCachedShowSelect;
    int64                        myPrimitiveVersion;
    int64                        myPosVersion;
    exint                        mySelectionId;
    exint                        mySelectionRevision;
    int                          myPostPassID;
    bool                         myNeedsDeferredPass;
    bool                         myNeedsParallelPass;

    // Accumulate a Count and a Sum of attribute data ids to know
    // if something changed.
    class DataIdsCache
    {
    public:
        DataIdsCache()
        : myDataIdsCount(0)
        , myDataIdsSum(0)
        {}

        bool operator==(const DataIdsCache &rhs) const
        {
            return myDataIdsCount==rhs.myDataIdsCount &&
                myDataIdsSum==rhs.myDataIdsSum;
        }

        void clear()
        {
            myDataIdsCount = 0;
            myDataIdsSum = 0;
        }

        void append(GA_DataId id)
        {
            myDataIdsCount++;
            myDataIdsSum += (exint)id;
        }
        
        void getDataIdsExcept_p_transform(const GA_Detail *gdp);

    private:
        exint myDataIdsCount;
        exint myDataIdsSum;
    };
    DataIdsCache myDataIds;
    DataIdsCache myDataIdsCache;

    UT_String                    myDopnetPath;
    
    // For determining if a display option which affects geometry has changed.
    int64                        myDispOptID;
    int                          myDispOptSerial;
    fpreal                       myLOD;
    bool                         myPolygonConvexQuality;
    bool                         myVertexNormalEnable;
    fpreal                       myVertexNormalCuspAngle;
    GR_DecorationOverride        myRequiredDecorations;
    bool                         myShowAllPoints;
    fpreal                       myDetailLOD;

    GUI_RenderMask               myRenderMask;
    GUI_DisplaySetType           myObjectState;
    GEO_ViewportLOD              myObjectLOD;
    bool                         myObjectDisplayAsSubdiv;

    GU_ConstDetailHandle         myDetailHandle;
    UT_Matrix4DArray             myDetailTransforms;
    UT_Matrix4DArray             myDetailInvTransforms;
    UT_Matrix4DArray             myReducedDetailTransforms;
    bool                         myDetailTransformIdentity;
    UT_Matrix4D                  myInstancerTransform;
    UT_Matrix4D                  myDetailFullTransform;
    bool                         myInstancerIdentityFlag;
    UT_IntArray                  myDetailGeoIndex;
    UT_BoundingBox               myLocalBBox;
    UT_BoundingBox               myWorldBBox; 
    int64                        myCachedInstanceVersion;
    int                          myRefineVersion;
    bool                         myObjectTransformDirty;
    bool                         myNeedsAlphaPassFlag;
    bool                         myPrimAlphaPassFlag;
    bool                         myIsDeferPass;
    bool                         myRefineOnLODChange;
    int                          mySelectionInstance;
    fpreal                       myLimitedInstanceFraction;
    bool                         myShowMaterials;
    int                          myFactoryMaterialOverrideId = -1;

    RE_CacheVersion              myInstanceSelectVersion;
    UT_BitArray                  myInstanceSelection;
    bool                         myHasInstanceSelection;

    // for GT_PrimInstance types, this holds the array of instance transforms
    // while its geometry is being refined.
    class gui_Instance
    {
    public:
        gui_Instance() { myBBox.makeInvalid(); }
        
        UT_Matrix4DArray         myTransforms;
        GU_ConstDetailHandle     myDetail;
        GT_PrimitiveHandle       myPrim;
        UT_BoundingBox           myBBox;
    };
    UT_Array<gui_Instance>       myInstancePrim;
    GT_AttributeListHandle       myInstancePrimAttribs;
    GT_AttributeListHandle       myInstancePointAttribs;
    
    class gui_DiskFile
    {
    public:
        gui_DiskFile() : myPrimIndex(0) {}
        UT_StringHolder myDiskFile;
        int             myPrimIndex;
    };
    UT_Array<gui_DiskFile>       myPackedDiskStack;
    
    int                          myPackedPrimLevel;
    GT_PrimitiveHandle           myPackedPrim;
    mutable bool                 myCachedUseSampleMask;
    mutable int                  myCachedSampleMask;
    mutable bool                 myCachedMultisample;
    mutable bool                 myCachedSampleCoverage;
    
    RE_Geometry                 *myPointGeo;
    RE_Geometry                 *myCubeGeoGL;
    RE_VertexArray              *myCubeInstanceGL;
    fpreal                       myCubeInstanceFraction;

    RE_ReflectMap               *myReflectMap;

    // last update and refinement time in visualization clock (counter)
    exint                        myVisUpdateTime;
    exint                        myVisRefineTime;

    UT_IntArray                  myUpdateVisualizers;
    UT_IntArray                  myRefineVisualizers;

    // if set to true in setup, updates are upgraded to full refinements.
    bool                         myRefineOnUpdate;
    unsigned                     myMaterialTextureFlag :1,
                                 myMaterialTexturePending :1,
                                 myMaterialHasDisplaceMap :1,
                                 myMaterialHasReflection :1,
                                 myMaterialUseOverrides :1,
                                 myMaterialTexCacheUpdate : 1,
                                 myHasTimeDepMaterials :1,
                                 myHasOpDepMaterials :1,
                                 myMSSEnable :1,
                                 myMSSPackedGeo :1,
                                 myMSSPerPrim :1,
                                 myMatCapDefault:1,
                                 myMatDrawUVMap:1;
    GUI_DisplayOption::gui_MatAssignMode myMatAssignMode;
    int                          myMaterialLimit;
    bool                         myMaterialLimitExceeded;
    int                          myObjMaterialID;
    DEP_MicroNode                myObjMaterialParm;
    UT_Set<int>                  myMaterialReferences;

    GT_DataArrayHandle           myBaseMaterialAssignments;
    GT_DataArrayHandle           myBaseMaterialRemap;
    int64                        myBaseMaterialPrevID;
    int64                        myBaseMaterialRemapPrevID;
    bool                         myForceMaterialUpdate;
    bool                         myMaterialAllowUpdates;


    UT_StringHolder              myPackedFoldersTopo;

    class gui_DetailAttribLists
    {
    public:
        bool    checkForAttribListChanges(const GU_Detail &dtl);

        UT_StringMap<bool> myPoint;
        UT_StringMap<bool> myVertex;
        UT_StringMap<bool> myPrim;
        UT_StringMap<bool> myDetail;

        UT_StringMap<bool> myVisAttribs;
    };

    gui_DetailAttribLists                        myDetailAttribLists;
    struct
    {
        UT_UniquePtr<GEO_DetachedHedgeInterface> interface;
        int                                      detail_id;
        int64                                    cache_version;
        int64                                    top_version;
    } myHedgeInterface[2];

    UT_UniquePtr<GEO_PrimClassifier>             myPrimClassifier;
    int                                          myPrimClassifierDetailId;
    int64                                        myPrimClassifierCacheVersion;
    int64                                        myPrimClassifierTopVersion;
    int64                                        myPrimClassifierSelectId;
    int64                                        myPrimClassifierSelectRevision;
    GU_Connectivity                              myPrimClassifierConnectivity;

    GA_GroupUPtr                                 myCachedGroup;
    GA_GroupType                                 myCachedGroupType;
    int                                          myCachedGroupDetailId;
    int64                                        myCachedGroupCacheVersion;
    int64                                        myCachedGroupTopVersion;

    int64                                        myCachedHidden3DVersion;
    
    fpreal                                       myDisplacementValue = -1.0;
    bool                                         myDisplacementChanged = false;
   
    static RE_ShaderHandle                       theBBoxShader;
    static RE_ShaderHandle                       theObjectPickShader;
    static RE_ShaderHandle                       theEdgeHighlightShader;
    static RE_ShaderHandle                       theEdgeHighlightUVShader;

    UT_StringMap<GT_PrimitiveHandle>             myAlembicArchives; 
    UT_StringMap<int>                            myUsedAlembicArchives;
    
    UT_StringHolder                              myUVDisplay;
    UT_Set<int>                                  myMatOpChanges;
public:
    // treat as private. For DM_RenderTable only.
    static bool registerHook(GUI_PrimitiveHook     *hook,
                             GT_PrimitiveType       gt_type,
                             int                    geo_type,
                             int                    priority,
                             GUI_PrimitiveHookFlags flags);

    friend class gr_PrimEntry;
};

inline void
GUI_GeoRender::setInstanceVersion(int64 version)
{
    myInstanceVersion = version;
}

inline int64
GUI_GeoRender::getInstanceVersion() const
{
    return myInstanceVersion;
}

inline const UT_DMatrix4 &
GUI_GeoRender::getDetailTransform(int index) const
{
    return myDetailTransforms(index);
}

inline const UT_DMatrix4 &
GUI_GeoRender::getDetailInvTransform(int index) const
{
    return myDetailInvTransforms(index);
}

#endif