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

#include "GR_PrimPacked.h"
#include <UT/UT_NonCopyable.h>
#include <GT/GT_PrimAgentShape.h>
#include <GT/GT_AgentSupport.h>

#ifdef USE_VULKAN
#include "GR_UtilsVK.h"
class RV_ShaderBlock;
class RV_ShaderVariableSet;
class GR_VulkanAgentData : public GT_VulkanAgentData
{
public:
    GR_VulkanAgentData() {}

    UT_NON_COPYABLE(GR_VulkanAgentData);

    UT_Array<UT_UniquePtr<RV_ShaderVariableSet>> BoneBlendSet;
    UT_Array<UT_UniquePtr<RV_ShaderBlock>>       RigTransforms;
    UT_Array<UT_UniquePtr<RV_ShaderBlock>>       BlendWeight;
    UT_Array<UT_UniquePtr<GR_InstanceBuffer>>    InstanceTransforms;
    UT_Array<UT_UniquePtr<GR_InstanceBuffer>>    Color;
    UT_Array<UT_UniquePtr<GR_InstanceBuffer>>    PrimID;
    UT_Array<UT_UniquePtr<GR_InstanceBuffer>>    Selection;
    UT_Array<RE_CacheVersion>                    SelVersion;
};
#endif


class GR_API GR_PrimAgentShape : public GR_PrimPacked
{
public:
             GR_PrimAgentShape(const GR_RenderInfo *info,
                               const char *cache_name,
                               const GT_PrimitiveHandle &pack_prim,
                               const GT_PrimitiveHandle &shape_prim);
            ~GR_PrimAgentShape() override;

    const char         *className() const override { return "GR_PrimAgentShape"; }
             
    GR_BasePrimType     getBasePrimType() const override
                                    { return GR_BASE_PRIM_AGENT_SHAPE; }

    GR_PrimAcceptResult acceptPrimitive(GT_PrimitiveType t,
                                        int geo_type,
                                        const GT_PrimitiveHandle &ph,
                                        const GEO_Primitive *prim) override;
    
    GR_DispOptChange    displayOptionChange(const GR_DisplayOption &opt,
                                            bool first_init) override;
    
    void                update(RE_RenderContext           r,
                               const GT_PrimitiveHandle  &primh,
                               const GR_UpdateParms      &p) override;

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

    int                 renderPick(RE_RenderContext r,
                                   const GR_DisplayOption *opt,
                                   unsigned int pick_type,
                                   GR_PickStyle pick_style,
                                   bool has_pick_map) override;

    bool                updateOnViewChange(
                                const GR_DisplayOption &opt) const override
                            { return opt.shadingMode() >= GR_FLAT_SHADED; }
    void                viewUpdate(RE_RenderContext r,
                                   const GR_ViewUpdateParms &parms) override;

    bool                inViewFrustum(
                                const UT_Matrix4D &objviewprojj,
                                const UT_BoundingBoxD *bbox = nullptr) override
                            { return myVisibilityFlag;  }
    
    bool                requiresAlphaPass() const override { return false; }
    bool                getSingleTransform(UT_Matrix4D &mat) const override
                            { return false; }

#ifdef USE_VULKAN
    static bool         initShaders(RV_Instance* inst);
    static void         cleanupShaders();
#endif
private:
    const GT_PrimAgentShape &getShape() const
    {
        return *UTverify_cast<const GT_PrimAgentShape *>(myPackedPrim.get());
    }

    void                 processVisibility(RE_RenderContext r,
                                        const GR_DisplayOption &dopts);
    void                 updateTransforms(RE_RenderContext r,
                                        const GU_ConstDetailHandle &geo,
                                        bool geo_changed);
    void                 updateInstanceTransforms(RE_RenderContext r,
                                        const GU_ConstDetailHandle &geo,
                                        bool geo_changed);
    void                 updateRigTransformsGL(RE_Render *r,
                                               const GU_ConstDetailHandle &geo,
                                               bool geo_changed);
    void                 updateBlendWeightsGL(RE_Render *r,
                                              const GU_ConstDetailHandle &geo,
                                              bool geo_changed);
    void                 processSelectionGL(RE_RenderContext r,
                                          const RE_CacheVersion &select_ver);
    
#ifdef USE_VULKAN
    void                 updateRigTransforms(RV_Render *r,
                                             const GU_ConstDetailHandle &geo,
                                             bool geo_changed);
    void                 updatePrimID(RV_Render *r, bool geo_changed);
    void                 updateColor(RV_Render *r, bool geo_changed);
    void                 processSelection(RV_Render *r,
                                        const RE_CacheVersion &select_version);
    void                 updateBlendWeights(RV_Render *r,
                                            const GU_ConstDetailHandle &geo,
                                            bool geo_changed);
#endif
    void                 freeVertexArrays();
    void                 updatePrimIDGL(RE_Render *r, bool geo_changed);
    void                 updateColorGL(RE_Render *r, bool geo_changed);

    int                  myLODLevel;
    int                  myTotalAgents;
    int64                myLastInstVersion;
    int                  myTransformSerial;
    int                  mySelectionSerial;
    int                  myRigSerial;
    GT_ShapeLODGroupHandle myShapeGroup;
    UT_IntArray          myTransformIndexMap;
    GR_UpdateReason      myDeferredReason;
    bool                 myDeformingShape;
    bool                 myVisibilityFlag;
    bool                 myLastWire;
    bool                 myLastLODEnable;
    fpreal               myLastLODBias;
    int                  myLastLODBase;

    // Only the primary LOD holds any of these.
    UT_Array<RE_VertexArray *>  myTransformVA;
    UT_Array<RE_VertexArray *>  myRigTransformVA;
    UT_Array<RE_VertexArray *>  myBlendWeightVA;
    UT_Array<RE_VertexArray *>  myShapeSelectionVA;
    UT_Array<RE_VertexArray *>  myPrimIDVA;
    UT_Array<RE_VertexArray *>  myColorVA;

#ifdef USE_VULKAN
    UT_UniquePtr<GR_VulkanAgentData>  myVulkanData;
#endif
};



#endif