GR_PrimPacked.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:        GR_PrimPacked.h (GR Library, C++)
 *
 * COMMENTS:
 */
#ifndef __GR_PrimPacked__
#define __GR_PrimPacked__

#include "GR_Primitive.h"
#include "GR_MaterialGroups.h"

#include <RE/RE_VertexArray.h>

#ifdef USE_VULKAN
class GR_InstanceBuffer;
typedef UT_UniquePtr<GR_InstanceBuffer> GR_InstanceBufferPtr;
#endif

class GR_API GR_PrimPacked : public GR_Primitive
{
public:
             GR_PrimPacked(const GR_RenderInfo *info,
                           const char *cache_name,
                           const GT_PrimitiveHandle &packed_prim,
                           const GT_PrimitiveHandle &instanced_prim,
                           const GU_ConstDetailHandle &instanced_gdp,
                           int prim_index = -1);

            ~GR_PrimPacked() override;

    const char          *className() const override { return "GR_PrimPacked"; }
             
    GR_BasePrimType             getBasePrimType() const override
                                { return GR_BASE_PRIM_PACKED; }
    GT_PrimitiveHandle          getInstancePrim() const override
                                { return myInstancedPrim; }

    const GT_PrimitiveHandle &instancePrim() const { return myInstancedPrim; }
    const GT_PrimitiveHandle &packedPrim() const   { return myPackedPrim; }

    void                setPackedPrim(const GT_PrimitiveHandle &packed_prim);
    void                setInstancedPrim(const GT_PrimitiveHandle &instance,
                                         const GU_ConstDetailHandle &inst_gdp);
    void                setPrimIndex(int pindex)
                            { myPrimIndex = pindex; }
    
    GR_PrimAcceptResult acceptPrimitive(GT_PrimitiveType t,
                                        int geo_type,
                                        const GT_PrimitiveHandle &ph,
                                        const GEO_Primitive *prim) override;

    void                update(RE_RenderContext           r,
                               const GT_PrimitiveHandle  &primh,
                               const GR_UpdateParms      &p) override;

    void                checkForDeferredDraw(const RE_RenderContext r,
                                             GR_RenderMode mode,
                                             GR_RenderFlags flags,
                                             const GR_DrawParms &dp,
                                             const UT_Matrix4D &proj_view,
                                             const UT_Matrix4D &object,
                                             const UT_Vector2F &min_proj_size,
                                             bool &visible,
                                             bool &defer) override;

    void                render(RE_RenderContext        r,
                               GR_RenderMode           render_mode,
                               GR_RenderFlags          flags,
                               GR_DrawParms            dp) override;

    void                renderDecoration(RE_RenderContext         r,
                                         GR_Decoration            decor,
                                         const GR_DecorationParms &parms) override;
    int                 renderPick(RE_RenderContext r,
                                   const GR_DisplayOption *opt,
                                   unsigned int pick_type,
                                   GR_PickStyle pick_style,
                                   bool has_pick_map) override;
    
    bool                checkForTransformChange();
       
    // Delegate these to the child prim.
    GR_DispOptChange     displayOptionChange(
                                const GR_DisplayOption &opts,
                                bool first_init) override;
    bool                 updateOnViewChange(
                                const GR_DisplayOption &) const override;
    void                 viewUpdate(
                                RE_RenderContext r,
                                const GR_ViewUpdateParms &parms) override;
    bool                 needsGLStateCheck(
                                const GR_DisplayOption &opts) const override;
    bool                 checkGLState(
                                RE_RenderContext r,
                                const GR_DisplayOption &opt) override;
    bool                 setup(const GR_DisplayOption *) override;
    void                 cleanup(RE_RenderContext r) override;

    bool                 requiresAlphaPass() const override;
    const GA_Primitive  *getGAPrimitive(const GU_Detail *gdp,
                                        exint primitive_id) const override;
    exint                getGAVertex(const GU_Detail *gdp,
                                     exint vertex_id) const override;
    RE_Geometry         *getDecorationGeometry() override;
    bool                 renderInAlphaPass(GR_AlphaPass a) override;
    bool                 inViewFrustum(
                                const UT_Matrix4D &objviewproj,
                                const UT_BoundingBoxD *bbox = nullptr) override;
    bool                 isRasterizedInView(
                                const UT_Matrix4F &objviewproj,
                                const UT_Vector2F &min_proj_size,
                                const UT_BoundingBoxF *bbox) override;
    bool                 getBoundingBox(UT_BoundingBoxD &bbox) const override;
 
    exint                getNumGLPrimitives(const GR_DisplayOption *) override;
    void                 retirePrimitive() override;

    GR_SelectMode        getSelectionMode(const GU_Detail &gdp,
                                          GU_SelectionHandle &selection) const;

    void                 setPickID(GA_Index prim_id, GA_Index point_id);

    void                 setInstanceHookPrim(GR_Primitive *prim);

    bool                 isPrimVisible() const override
                         { return myPrimVisible; }
    void                 setPrimVisible(bool v)
                         { myPrimVisible = v; }

protected:
    virtual int          getNumInstances() const { return 1; }
    virtual UT_Matrix4D  getTransform(int ) const
                                { return myInstancePrimTransform; }
    virtual bool         isFragment() const { return false; }
    virtual bool         getSingleTransform(UT_Matrix4D &mat) const
                            { mat = myInstancePrimTransform; return true; }

    bool                 updateCacheName(const GT_PrimitiveHandle &iph,
                                         const GR_UpdateParms &p,
                                         bool fallback);
    void                 updateInstanceGeometry(RE_RenderContext r,
                                      const GT_PrimitiveHandle &container_prim,
                                                const GR_UpdateParms &p,
                                                bool build_anchors,
                                                GR_UpdateReason full_update);
    
    bool                 fetchBoundingBox(UT_BoundingBoxD &bbox) const;
    virtual void         buildAnchorsGL3(RE_RenderContext r,
                                         const GR_UpdateParms &p,
                                         GR_UpdateReason full_reason,
                                         const GT_PrimitiveHandle &xforms);
    void                 buildPickID(const GT_PrimitiveHandle &pid);
    RE_Geometry         *buildPickBBox(RE_RenderContext r) const;
    void                 buildInstPrimTransform();

    // Given the packed geometry handle and the update reason for the packed
    // primitive, determine the update reason for the packed geometry. 
    GR_UpdateReason      checkForPackedGeoChanges(const GT_PrimitiveHandle &ph,
                                                  GR_UpdateReason reason);
    GR_UpdateParms checkForPackedMaterialAssignment(const GR_UpdateParms &p);
    
    void                 updateLightLinking();
    void                 updateLinkMap(const UT_StringRef &attrib_name,
                                       UT_StringMap<int> &link_map,
                                       UT_StringArray &list,
                                       bool &has_link);
    bool                 setLightLinkMask(GR_DrawParms &dp,
                                          int &prev_mask) const;
    void                 restoreLightLinkMask(GR_DrawParms &dp,
                                              int prev_mask) const;
  

    // Packed primitive
    GT_PrimitiveHandle   myPackedPrim;
    RE_Geometry         *myCenterPoints;
    RE_Geometry         *myCenterPrims;
    RE_CacheVersion      myCenterPointCacheVersion;

    // Instanced (contained) primitive
    GR_PrimitivePtr      myInstance;
    GU_ConstDetailHandle myInstancedDetail;
    GT_PrimitiveHandle   myInstancedPrim;
    GT_PrimitiveType     myInstancedPrimType;
    int64                myInstancedDetailID;
    int64                myInstancedDetailCacheCount;
    UT_Vector3F          myInstancePoint;
    UT_Matrix4D          myInstancePrimTransform;
    UT_BoundingBox      *myAssignedBBox;
    UT_Matrix4D          myBBoxTransform;
    RE_VertexArray      *myColorVA;
#ifdef USE_VULKAN
    GR_InstanceBufferPtr myColorBuf;
#endif

    GR_SelectMode        mySelectMode;
    GR_SelectMode        myPointSelectMode;
    int64                myTopVersion;
    int64                myMatVersion;
    int64                myPrimVersion;
    int64                myPackedPVersion;
    int64                myAlembicVersion;

    GT_DataArrayHandle   myPickIDs;
    GT_DataArrayHandle   myPrimIDs;
    GT_DataArrayHandle   myPointIDs;
    GT_DataArrayHandle   myLODMask;
    UT_IntArray          myBBoxInstances;
    UT_IntArray          myPointInstances;

    RE_VertexArrayRef    myCenterPointP;
    RE_VertexArrayRef    myCenterPointInstMat;
    RE_VertexArrayRef    myCenterPrimP;
    RE_VertexArrayRef    myCenterPrimInstMat;
    RE_VertexArray      *mySelectionVA;
#ifdef USE_VULKAN
    GR_InstanceBufferPtr mySelectionBuf;
#endif
    bool                 myPrimSwappedFlag;
    bool                 myPrimTypeChanged;
    int64                myPrimUniqueID;
    
    GR_MaterialGroups    myMatGroups;
    UT_Map<int, UT_IntArray> myMaterialGroups;

    bool                 myIsVisible;
    bool                 myPrimVisible;
    bool                 myQueuedDrawValid;
    bool                 myIsConsolidatedMesh;
    int                  myQueuedBBoxID;

    mutable UT_BoundingBoxD myCachedBBox;
    mutable bool            myCachedBBoxValid;
    
    // light linking in lops
    UT_StringArray       myLightLinks;
    UT_StringMap<int>    myLightLinkMap;
    bool                 myHasLightLink;
    UT_StringArray       myShadowMasks;
    UT_StringMap<int>    myShadowMaskMap;
    bool                 myHasShadowMask;
    
    // For GR_PrimPacked only
    GA_Index             myPrimID;

    GA_Index             myOverridePointID;
    GA_Index             myOverridePrimID;

    int                  myPrimIndex;
    // --------
};

class GR_API GR_PrimPackedMesh : public GR_PrimPacked
{
public:
    GR_PrimPackedMesh(const GR_RenderInfo *info,
                      const char *cache_name,
                      const GT_PrimitiveHandle &packed_prim,
                      const GT_PrimitiveHandle &instanced_prim,
                      const GU_ConstDetailHandle &instanced_gdp)
    : GR_PrimPacked(info, cache_name,packed_prim,instanced_prim,instanced_gdp)
        {}


    const char      *className() const override { return "GR_PrimPackedMesh"; }
             
    GR_BasePrimType  getBasePrimType() const override
                                { return GR_BASE_PRIM_PACKED_MESH; }
};


inline GR_Primitive::GR_DispOptChange
GR_PrimPacked::displayOptionChange(const GR_DisplayOption &opts,
                                   bool first_init)
{
    if(myInstance)
        return myInstance->checkDisplayOptionChange(opts);
    return DISPLAY_UNCHANGED;
}

inline bool
GR_PrimPacked::updateOnViewChange(const GR_DisplayOption &opt) const
{
    if(myInstance)
        return myInstance->updateOnViewChange(opt);
    return false;
}

inline void     
GR_PrimPacked::viewUpdate(RE_RenderContext r, const GR_ViewUpdateParms &parms)
{
    if(myInstance)
        myInstance->viewUpdate(r, parms);
}

inline bool     
GR_PrimPacked::needsGLStateCheck(const GR_DisplayOption &opts) const
{
    if(myInstance)
        return myInstance->needsGLStateCheck(opts);
    return false;
}

inline bool     
GR_PrimPacked::checkGLState(RE_RenderContext r,const GR_DisplayOption &opts)
{
    if(myInstance)
        return myInstance->checkGLState(r,opts);
    return false;
}

inline bool     
GR_PrimPacked::setup(const GR_DisplayOption *d)
{
    if(myInstance)
        return myInstance->setup(d);
    return false;
}

inline void     
GR_PrimPacked::cleanup(RE_RenderContext r)
{
    if(myInstance)
        myInstance->cleanup(r);
}


inline bool     
GR_PrimPacked::requiresAlphaPass() const
{
    if(myInstance)
        return myInstance->requiresAlphaPass();
    return false;
}

inline const GA_Primitive *
GR_PrimPacked::getGAPrimitive(const GU_Detail *gdp,
                              exint primitive_id) const
{
    if(myInstance)
        return myInstance->getGAPrimitive(gdp, primitive_id);
    return NULL;
}

inline exint     
GR_PrimPacked::getGAVertex(const GU_Detail *gdp,
                           exint vertex_id) const
{
    if(myInstance)
        return myInstance->getGAVertex(gdp, vertex_id);
    return exint(-1);
}

inline RE_Geometry *
GR_PrimPacked::getDecorationGeometry()
{
    return NULL;
}

inline bool     
GR_PrimPacked::renderInAlphaPass(GR_AlphaPass a)
{
    if(myInstance)
        return myInstance->renderInAlphaPass(a);
    return true;
}

inline bool
GR_PrimPacked::inViewFrustum(const UT_Matrix4D &objviewproj,
                             const UT_BoundingBoxD *bbox)
{
    if(myInstance)
        return myInstance->inViewFrustum(objviewproj, bbox);
    // if no instance, no point in rendering nothing, so cull
    return false;
}

inline bool
GR_PrimPacked::isRasterizedInView(const UT_Matrix4F &objviewproj,
                                  const UT_Vector2F &min_proj_size,
                                  const UT_BoundingBoxF *bbox)
{
    if(myInstance)
        return myInstance->isRasterizedInView(objviewproj, min_proj_size,bbox);
    // if no instance, no point in rendering nothing, so cull
    return false;
}

inline bool
GR_PrimPacked::getBoundingBox(UT_BoundingBoxD &bbox) const
{
    return myInstance ? myInstance->getBoundingBox(bbox) : false;
}

inline exint
GR_PrimPacked::getNumGLPrimitives(const GR_DisplayOption *opt)
{
    return myInstance ? myInstance->getNumGLPrimitives(opt) : 0;
}

#endif