GR_GeoRenderVK.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_GeoRenderVK.h ( GR Library, C++)
 *
 * COMMENTS:
 *      Base class for all drawing methds that Houdini is natively capable of
 *      rendering with Vulkan.
 */

#ifndef GR_GeoRenderVK_h
#define GR_GeoRenderVK_h

#include "GR_API.h"

#include "GR_GeoRender.h"

#include <GT/GT_Handles.h>

#include <RV/RV_Type.h>
#include <RV/RV_Geometry.h> // for `RV_OverrideList`

#include <UT/UT_Array.h>
#include <UT/UT_BoundingBox.h>
#include <UT/UT_UniquePtr.h>
#include <UT/UT_Options.h>
#include <UT/UT_UniquePtr.h>

#include "GR_DecorationRender.h"

class RV_Geometry;
class RV_Render;
class RV_ShaderVariableSet;
class RV_ShaderBlock;
class RV_VKPipelineStateInfo;
class RV_ShaderAtlas;
class RV_VKBuffer;
class RV_VKImage;
class RV_VKAccelerationStructure;

class GR_InstanceBuffer;
class GR_Uniforms;
class GR_FillAttributesVK;
class gr_AttribInfoVK;
class gr_AttribCacheVK;
typedef UT_UniquePtr<GR_FillAttributesVK> GR_FillAttributesVKPtr;

// Multithreaded filling of attribute arrays 
// TODO: replace with function pointer?
//       or override?
enum gr_FillType
{
    GR_FILL_REGULAR,
    GR_FILL_POINT,
    GR_FILL_POINT_ID,
    GR_FILL_PRIM_ID,
    GR_FILL_CREATE_NORMAL,
    GR_FILL_STRING_ATTRIB,
    GR_FILL_MATERIAL_ATTRIB,
    GR_FILL_TANGENT_ATTRIB,
    GR_FILL_INSTANCE_REGULAR,
    GR_FILL_INSTANCE_TRANSFORM,
    GR_FILL_OPENCL_BUFFER,
    GR_FILL_OPENCL_NORMAL
};

class GR_API GR_GeoRenderVK : public GR_GeoRender
{
public:
     GR_GeoRenderVK(GR_Primitive *parent_prim);
    ~GR_GeoRenderVK() override;

    virtual bool supportsRayTrace() const
    {
        return false;
    }

    RV_Geometry* createGeometryVK(exint num_points);

    RV_Geometry* getVkGeometry() override
    {
        return myGeometryVk.get();
    }

    static bool initShaders(RV_Instance *inst);
    static void cleanupShaders();

    virtual void getVkDecorConnectGroup(RV_PrimType render_prim,
                                    bool is_uv_view,
                                    int &out_connect_start,
                                    int &out_connect_num) {} // = 0;

    static void           fillGeoAttribs( RV_Render           *r,
                                          const GT_Primitive  *prim,
                                          const GR_UpdateParms&p,
                                          RV_Geometry         *geo,
                                          GR_FillAttributesVK *attrib_fill,
                                          bool                 needs_normal,
                                          bool                 needs_uv,
                                          bool                 needs_tangent,
                                          bool                 need_prim_vert_info, 
                                          const GT_DataArrayHandle &point_normals,
                                          GR_BasePrimType      packed_type,
                                          bool                 build_point_id,
                                          bool                 build_prim_id,
                                          GR_GeoRenderVK      *geo_ren,
                                          bool                *has_detail_prim_id,
                                          int                 *detail_prim_id,
                                          int                 *num_bone_deform);

    void                fillAttributesVK( RV_Render            *r,
                                          const GT_Primitive   *prim,
                                          const GR_UpdateParms &p,
                                          RV_Geometry    *geo,
                                          GR_FillAttributesVK *attrib_fill,
                                          bool           needs_nml,
                                          bool           needs_uv,
                                          bool           needs_tangent,
                                          bool           need_prim_vert_info, 
                                          const GT_DataArrayHandle &point_norm);

    void                    buildPointID( RV_Render *r,
                                          const GR_DisplayOption &dopts,
                                          RV_Geometry *rv_geo,
                                          GR_FillAttributesVK *attrib_fill,
                                          const GT_Primitive &prim,
                                          const GU_ConstDetailHandle &geo,
                                          const RE_CacheVersion &ver);

    bool       buildInstanceObjectAttrib( RV_Render *r,
                                          const GT_PrimitiveHandle &h,
                                          const GR_UpdateParms &p,
                                          RV_Geometry *geo,
                                          GR_FillAttributesVK *attrib_fill,
                                          const UT_Matrix4DArray *instance_trans,
                                          const RE_CacheVersion &instance_version,
                                          int instance_group,
                                          UT_Matrix4D *out_transform);

    static void           addAttribArray( RV_Render                *r,
                                          RV_Geometry              *geo,
                                          GR_FillAttributesVK      *attrib_fill,
                                          const char               *attrib_name,
                                          RV_AttributeType          array_type,
                                          const GT_DataArrayHandle &dh,
                                          const GR_DisplayOption   &opts,
                                          const RE_CacheVersion    &geo_ver,
                                          const gr_FillType        &fill_type,
                                          const GT_Owner           original_type = GT_OWNER_INVALID,
                                          bool          *is_ce_attrib = nullptr);
    static void           addAttribArray( RV_Render                *r,
                                          RV_Geometry              *geo,
                                          GR_FillAttributesVK      *attrib_fill,
                                          const char               *attrib_name,
                                          RV_AttributeType          array_type,
                                          const GT_DataArrayHandle &dh,
                                          const GT_DataArrayHandle &dhn,
                                          const GT_DataArrayHandle &dhv,
                                          const GT_DataArrayHandle &dhvid,
                                          const GR_DisplayOption   &opts,
                                          const RE_CacheVersion    &geo_ver,
                                          const gr_FillType        &fill_type,
                                          const GT_Owner           original_type = GT_OWNER_INVALID,
                                          bool          *is_ce_attrib = nullptr);

    void          addExternalAttribArray( RV_Render                *r,
                                          RV_Geometry              *geo,
                                          GR_FillAttributesVK      *attrib_fill,
                                          const char               *attrib_name,
                                          RV_AttributeType          array_type,
                                          const GT_DataArrayHandle &dh,
                                          const GR_DisplayOption   &opts,
                                          bool fill_immediately);

    void              addInstAttribArray( RV_Render                *r,
                                          RV_Geometry              *geo,
                                          GR_FillAttributesVK      *attrib_fill,
                                          const char               *attrib_name,
                                          int                       inst_group,
                                          RV_AttributeType          array_type,
                                          const GT_DataArrayHandle &dh,
                                          const GR_DisplayOption   &opts,
                                          const RE_CacheVersion    &geo_ver,
                                          const gr_FillType        &fill_type);

    void              cleanupGeoOverride( RV_Render *r,
                                          const GR_DisplayOption *opt,
                                          RV_Geometry *geo);

    void                setupGeoOverride( RV_Render *r,
                                          const GR_DisplayOption *opt,
                                          RV_Geometry *geo,
                                          UT_UniquePtr<RV_OverrideList> &
                                              override_list);
    
    void                setupGeoOverride( RV_Render *r,
                                          const GR_DisplayOption *opt,
                                          RV_Geometry *geo,
                                          UT_SharedPtr<RV_OverrideList> &
                                              override_list);

    // Called by wire primitives (curves and points) to add a Cd override
    // if the Geometry is supposed to have a special color
    void                 updateWireColor(RV_Render *r,
                                          GR_Uniforms *u,
                                          RV_Geometry *geo,
                                          const GR_DisplayOption *opt,
                                          bool allow_color_override,
                                          RV_OverrideList& overrides) const;

    void                 updateWireOverColor(RV_Render *r,
                                          GR_Uniforms *u,
                                          RV_Geometry *geo,
                                          const GR_DisplayOption *opt,
                                          bool allow_color_override,
                                          RV_OverrideList& overrides) const;

    GR_FillAttributesVKPtr  createFillTask( RV_Render *r,
                                          GR_GeoRenderVK *gr,
                                          const GT_Primitive *prim,
                                          const GU_Detail *geo,
                                          const GR_DisplayOption *opts,
                                          int num_points);
    void                     runFillTask( RV_Render            *r,
                                          RV_Geometry          *geo,
                                          GR_FillAttributesVK  *attrib_fill
                                        );

    void        updateInstanceGroupBuffer(const GR_InstanceBuffer *buffer,
                                          int instance_group);

    void        gpuMemoryUsage(exint &used_bytes,
                               exint &unused_bytes,
                               exint &pinned_bytes) override;

    // Optionally overriden by geometries that should be traced against
    virtual void updateAccelerationStructure(RV_Render *r,
                                             int tag,
                                             int light_id,
                                             const UT_Matrix4F &obj_mat);

    virtual RV_VKAccelerationStructure* getAccelerationStructure();

    void         prepareForRayTrace(RV_Render *r,
                                    int tag,
                                    int light_id,
                                    const UT_Matrix4F &obj_mat);

protected:

    bool        initTransformAndPassInfo(RV_Render *r,
                                         GR_Uniforms *u,
                                         const RV_ShaderProgramBase *shader);
    
    GR_SelectMode         buildSelection( RV_Render*r,
                                          const GR_UpdateParms     &p,
                                          RV_Geometry              *geo,
                                          GR_FillAttributesVK      *attrib_fill,
                                          const GT_PrimitiveHandle &primh,
                                          const GT_DataArrayHandle &vertex_list);

    // Generate normals with compute shaders. The geometry must have the given
    // connect group, as well as P, N, and PointIndex attributes.
    // P and N must each have a vector size of 4.
    bool        generateNormalsGPU(RV_Render *r,
                                   RV_Geometry *geo,
                                   int connect_index,
                                   const GR_DisplayOption &opts);

    void        clearScratchData();

    // --------------------------------------------------
    // gr_SetCache
    //
    // Sets keyed by their pipeline
    // TOOD: not enforced, but ideally should be a small number of sets
    //       e.g. sets with same/similar layout but used with pipelines that
    //            have different usage state (e.g. Vertex-Only, or Frag-and-Vertex)
    // TODO: could also have a mechanism in RV_ShaderAtlas to enforce that all
    //       sets with the same members and per-set locations also have the same
    //       per-layout locations
    // TODO: per-frame use counting and reset function
    struct gr_SetCache
    {

        // Array doing linear lookup, fine if number of sets small
        // TODO: could do a hashmap
        UT_Array<UT_UniquePtr<RV_ShaderVariableSet>> mySets;
        RV_ShaderVariableSet*                        myLastSet = nullptr;

        RV_ShaderVariableSet *createOrReuseSet(
                RV_Render *r,
                int set_num,
                const RV_ShaderProgramBase *shader,
                bool *out_is_new = nullptr);
    };
    gr_SetCache myObjectSet;
    gr_SetCache myShaderSet;

    //      NOTE: individual shader blocks may not work if object 
    //      drawn multiple times
    //
    //       In the ideal case: the Specific GR_GeoRender child class  
    //       knows/controls the Shaders it will be using and 
    //       knows how many Descriptor Sets / memory blocks that requires 
    //       (and minus those managed by the RV_Geometry)
    //       ..
    //       Note this ONLY works for the case where the object is drawn once
    //       because:
    //          - uploads can't be done inside a render pass
    //          - so uniforms can't be updated during a render pass
    //          - so all uniforms have to be setup pre-render pass
    //          - so, if some GeoRender needs to be updated/drawn multiple
    //            times in a single pass, will need multiple allocated ubo's
    //      could fix by baking some re-allocation on-upload functionality into
    //      ShaderBlock (like is already done in the Descriptor Set class)
    //UT_UniquePtr<RV_ShaderVariableSet>  myObjectSet;
    //UT_UniquePtr<RV_ShaderVariableSet>  myGlobalSet;
    //UT_UniquePtr<RV_ShaderVariableSet>  myShaderSet;


    UT_UniquePtr<RV_ShaderBlock>        myTransformBlock;
    UT_UniquePtr<RV_ShaderBlock>        myColorOverrideBlock;
    UT_UniquePtr<RV_VKImage>            myColorOverrideRampBuffer;
    UT_UniquePtr<gr_AttribCacheVK>      myAttribCache;

    UT_UniquePtr<RV_Geometry> myGeometryVk;

    bool myHasSurface;

private:
    UT_UniquePtr<RV_VKBuffer>           myNormalScratchBuffer;
};


// --------------------------------------------------
// GR_FillAttributesVK
//
// Helper class to fill attributes, represented as gr_AttribInfoVK
class GR_API GR_FillAttributesVK
{
public:
     
    GR_FillAttributesVK(RV_Render *r,
                         const GT_Primitive *prim,
                         const GU_Detail *geo,
                         const GR_DisplayOption *opts,
                         int num_points);
    ~GR_FillAttributesVK();

    int entries() const { return myAttribs.entries(); }

    bool hasBounds() const { return myHasPosBounds || myHasDetailBounds; }
    bool hasCLNormal() const { return myHasCLNormal; }
    const UT_BoundingBox getBounds() const
            {
                if (myHasPosBounds)
                {
                    return myPosBounds;
                }
                if (myHasDetailBounds)
                {
                    return myDetailBounds;
                }
                return UT_BoundingBox();
            }

    void        allocateStagingBuffer(RV_Render* r);

    void        process(const UT_BlockedRange<int> &range) const;

    gr_AttribInfoVK   *append(
                         const char *name,
                         gr_FillType t,
                         RV_AttributeType at,
                         const GT_DataArrayHandle &h,
                         RE_CacheVersion v,
                         int size = 0,
                         GT_DataArrayHandle h2 = GT_DataArrayHandle(),
                         GT_DataArrayHandle h3 = GT_DataArrayHandle(),
                         GT_DataArrayHandle vl = GT_DataArrayHandle(),
                         int instance_group = -1);

    void        upload(RV_Render *r, RV_Geometry *geo);

    int getFillAmount()
        { return myFillAmount; }
    void addToFillAmount(int n) 
        { myFillAmount += n; }

    // Attribute default values (if they don't exist).
    void setFallbacks(const UT_Options *fallbacks);
    void addIntFallback(const UT_StringHolder &name, int value);
    void addFallback(const UT_StringHolder &name, fpreal value);
    void addFallback(const UT_StringHolder &name, const UT_Vector2F &value);
    void addFallback(const UT_StringHolder &name, const UT_Vector3F &value);
    void addFallback(const UT_StringHolder &name, const UT_Vector4F &value);

    bool getFallback(const UT_StringHolder &name, int &value) const;
    bool getFallback(const UT_StringHolder &name, fpreal &value) const;
    bool getFallback(const UT_StringHolder &name, UT_Vector2F &value) const;
    bool getFallback(const UT_StringHolder &name, UT_Vector3F &value) const;
    bool getFallback(const UT_StringHolder &name, UT_Vector4F &value) const;
    UT_OptionType getFallbackType(const UT_StringHolder &name) const;

    bool usedFallback() const { return myUsedFallback; }
    void setUsedFallback(bool used) { myUsedFallback = used; }
    void setAttribCache(gr_AttribCacheVK *cache) { myAttribCache = cache; }
private:
    const void *fillConstAttribute(gr_AttribInfoVK *attrib) const;
    const void *fillRegularAttribute(gr_AttribInfoVK *attrib) const;
    const void *fillPointAttribute(gr_AttribInfoVK *attrib) const;
    const void *fillPointIDAttribute(gr_AttribInfoVK *attrib) const;
    const void *fillPrimIDAttribute(gr_AttribInfoVK *attrib) const;
    const void *fillStringAttribute(gr_AttribInfoVK *attrib) const;
    const void *fillMaterialAttribute(gr_AttribInfoVK *attrib) const;
    const void *fillTangentAttribute(gr_AttribInfoVK *attrib) const;
    const void *fillBoneAttributes(gr_AttribInfoVK *attrib) const;

    void        createNormalAttribute(gr_AttribInfoVK *attrib) const;
        
    RV_Render                           *myRender;
    const GU_Detail                     *myDetail;
    const GR_DisplayOption              *myDisplayOpts;
    const GT_Primitive                  *myPrim;
    gr_AttribCacheVK                    *myAttribCache;
    UT_Array<gr_AttribInfoVK *>          myAttribs;
    int                                  myNumPoints;

    UT_UniquePtr<RV_VKBuffer>            myStagingBuffer;

    void computeDetailBounds();
    bool                                 myHasDetailBounds;
    UT_BoundingBox                       myDetailBounds;

    bool                                 myHasPosBounds;
    UT_BoundingBox                       myPosBounds;

    UT_Array<GT_DataArrayHandle>         myDataHandles;
    int                                  myFillAmount;

    UT_Options                           myFallbacks;
    bool                                 myUsedFallback = false;
    bool                                 myHasCLNormal = false;

    friend gr_AttribInfoVK;
};


#endif