GR_PolySurfaceVK.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_PolySurfaceVK ( GR Library, C++)
 *
 * COMMENTS:
 *      Line and ribbon primitive.
 */
#ifndef GR_PolySurfaceVK_h
#define GR_PolySurfaceVK_h

#include "GR_API.h"
#include "GR_GeoRenderVK.h"
#include <GT/GT_PrimPolygonMesh.h>
#include <RV/RV_Geometry.h>
#include <UT/UT_Map.h>

class RV_Geometry;
class RV_Render;
class RV_ShaderProgram;
class GR_Material;
class RV_VKBuffer;

namespace GR_Utils
{
class RadixSortGPU;
}

class GR_API GR_PolySurfaceVK : public GR_GeoRenderVK
{
public:
             GR_PolySurfaceVK(GR_Primitive *prim);
            ~GR_PolySurfaceVK() override;

    const char         *className() const override { return "GR_PolySurfaceVK"; }
    
    void                getPickConnectGroup(unsigned int pick_mode,
                                            GR_PickGeometry pick_geo,
                                            int &out_connect_start,
                                            int &out_connect_num) override;
                                            
    RV_Geometry        *getVkPickGeometry(unsigned int pick_mode) override;

    void                getVkDecorConnectGroup(RV_PrimType render_prim,
                                    bool is_uv_view,
                                    int &out_connect_start,
                                    int &out_connect_num) override;

    void                update(RE_RenderContext rc,
                               const GT_PrimitiveHandle &primh,
                               const GR_UpdateParms     &parms,
                               const char               *cache_name) override;
    void                viewUpdate(RE_RenderContext rc,
                                   const GR_DisplayOption &opts,
                                   const char *cache_name,
                                   RE_CacheVersion geo_version,
                                   RE_CacheVersion select_version) override;
    
    void                draw(RE_RenderContext rc,
                             GR_RenderMode mode,
                             GR_RenderFlags flags,
                             GR_DrawParms dp) override;
    
    exint               getNumGLPrimitives() const override;
    bool                hasTransparency() const override
                            { return myHasAlpha || myHasBlendedMaterial; }
    bool                needsViewUpdate() const { return myTransparencySort; }

    // Enable backface culling and face winding for the draw, accounting for 
    // the winding order of this polysurface's geometry
    void                enableBackfaceCulling(RV_Render* r, bool do_cull) const;
    bool                hasReverseWinding() const { return myWindingOrder; }
    bool                hasAutoGenNormals() const { return myAutoGenNormal; }
    void                setTransparencyFlags(bool sort_enabled)
                        {
                            myUseParentTransparencyFlags = true;
                            myParentTransparencySort = sort_enabled;
                        }

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

    const GT_PrimitiveHandle &getMesh() const { return myFlattenedMesh; }
    const GT_PrimitiveHandle &getConvexedMesh() const {return myConvexedMesh;}

    bool supportsRayTrace() const override { return true; }
    void retireGeometry() override;

    void updateAccelerationStructure(RV_Render* r,
                                     int tag,
                                     int light_id,
                                     const UT_Matrix4F &obj_mat) override;
    RV_VKAccelerationStructure* getAccelerationStructure() override;

protected:
    // This function takes exclusive ownership of the subdivision geometry
    // object, which will be used to draw subdivided surface by PolySurfaceVK.
    // Called after subdivision surface setup in OSDSubdSurfaceVK::update().
    void                setupSubDGeometry(UT_UniquePtr<RV_Geometry> geo);
    UT_UniquePtr<RV_Geometry> takeSubDGeometry()
                            { return std::move(mySubDGeometry); }
    RV_Geometry        *getSubDGeometry() const
                            { return mySubDGeometry.get(); }

    // Update only the draw state needed for subdivision path. Returns false when
    // the caller should fall back to the full PolySurfaceVK::update().
    bool                syncSubDRenderState(RE_RenderContext rc,
                                            GT_PrimPolygonMesh *pmesh,
                                            const GR_UpdateParms &p);

private:
    void                clearTransparencySortGPU();
    void                setupTransparencySortGPU(RV_Render *r,
                                                 const GT_PrimPolygonMesh *pmesh,
                                                 exint tri_count);
    
    void                updateSurface(RV_Render            *r,
                                      GT_PrimPolygonMesh   *pmesh,
                                      const GR_UpdateParms &p,
                                      bool                  needs_tangents,
                                      GR_Material          *material,
                                      const char           *cache_name);

    void                convexAndFlattenMesh(GT_PrimPolygonMesh  *pmesh,
                                             GR_UpdateParms      &parms,
                                             bool                 needs_tangents,
                                             GT_PrimPolygonMesh* &out_cmesh,
                                             bool                &out_flattened);

    void                buildNormals(GT_PrimPolygonMesh   *pmesh,
                                     const GR_UpdateParms &parms,
                                     bool                  needs_tangents,
                                     GT_PrimPolygonMesh*  &out_nmesh);

    void                buildSurfaceConnectivity(const GT_PrimPolygonMesh *pmesh,
                                                 const GR_UpdateParms   &parms,
                                                 UT_Int32Array &connect_indices);
    
    void                buildVertexNumbers(const GT_PrimPolygonMesh *pmesh,
                                              const GR_UpdateParms  &parms,
                                              GT_Int8Array &vert_num);

    void                buildWireframeConnectivity(
                                        const GT_PrimPolygonMesh *pmesh,
                                        const GR_UpdateParms    &parms,
                                        UT_Int32Array &connect_indices,
                                        UT_Int32Array &faces,
                                        bool target_vert = false);
    
    void                buildRTSurfaceConnectivity(const GT_PrimPolygonMesh *pmesh,
                                                   const GR_UpdateParms &parms,
                                                   UT_Int32Array &connect_indices);

    void                buildUVBoundaryConnectivity(
                                             const GT_PrimPolygonMesh *pmesh,
                                             const GR_UpdateParms       &p,
                                             UT_Int32Array &connect,
                                             UT_Int32Array &face_list);

    void                buildInstanceTransform(RV_Render *r,
                                               GT_PrimitiveHandle primh,
                                               const GR_UpdateParms     &p,
                                               RV_Geometry *geo);

    RV_ShaderProgram *  fetchShader(RV_Render *r,
                                    GR_RenderMode mode,
                                    GR_RenderFlags flags,
                                    const GR_Material *mat,
                                    const GR_DisplayOption *opts,
                                    bool &uses_mat);

    bool                updateBoneTransforms(RV_Render *r,
                                             const GT_DataArrayHandle &a);

    void                updateBlendShapes(RV_Render *r,
                                          const GT_DataArrayHandle &a);

    bool                needsSkinningOrBlendshapes(GR_RenderFlags flags) const;
    bool                applyDisplacementMap(RE_RenderContext rc,
                                             const GR_UpdateParms &p,
                                             GR_Material *mat);


    GT_PrimitiveHandle  myNormalMesh;           // with generated normals
    GT_PrimitiveHandle  myTangentMesh;          // with generated tangents
    GT_PrimitiveHandle  myFlattenedMesh;        // with only Point/Detail attribs

    GT_PrimitiveHandle  myBaseMesh;             // original
    GT_PrimitiveHandle  myConvexedMesh;         // convexed
    GT_PrimitiveHandle  myTransparencySortMesh;
    
    GT_DataArrayHandle myGeneratedNormals;
    GT_Owner           myNormalsOwner;
    GT_DataArrayHandle myGeneratedTangents;
    GT_Owner           myTangentsOwner;
    GT_DataArrayHandle myGeneratedBitangents;
    GT_Owner           myBitangentsOwner;

    GT_DataArrayHandle myConvexUniformIndirect;
    GT_DataArrayHandle myConvexVertexIndirect;
    GT_DataArrayHandle myConvexVertexList;
    GT_DataArrayHandle myConvexPrimInfo;
    GT_DataArrayHandle myConvexVertInfo;

    UT_StringHolder    myUVAttrib;
    int64              myUVver;

    int                 myMaterialID = 0;
    bool                myHasTangents = false;
    bool                myWindingOrder = false;
    bool                myAutoGenNormal = false;
    bool                myIsFlattened = false;
    bool                myHasCd = false;
    bool                myHasAlpha = false;
    bool                myHasBlendedMaterial = false;
    bool                myTransparencySort = false;
    bool                myUseParentTransparencyFlags = false;
    bool                myParentTransparencySort = false;
    bool                myHasNormalOffsets = false;
    bool                myRanDisplacement = false;
    int                 myNumBlendShapes = 0;
    int                 myNumBoneTransforms = 0;

    int64               myTopVersion = -1;
    int64               myPointVer = -1;
    UT_UniquePtr<RV_Geometry> myDisplaceGeometry;

    UT_UniquePtr<RV_Geometry> mySubDGeometry;

    gr_SetCache         myBoneBlendSet;
    UT_UniquePtr<RV_ShaderBlock> myBoneTransforms;
    UT_UniquePtr<RV_ShaderBlock> myBlendShapes;
    bool                myIsMatXMaterial = false;
    UT_UniquePtr<GT_GEOOffsetList> myVertexOffsets;

    UT_UniquePtr<RV_ShaderVariableSet> myTessellateInSet;
    UT_UniquePtr<RV_ShaderVariableSet> myTessellateOutSet;
    UT_UniquePtr<RV_ShaderVariableSet> myTransparencySortKeysInSet;
    UT_UniquePtr<RV_ShaderVariableSet> myTransparencySortKeysOutSet;
    UT_UniquePtr<RV_ShaderVariableSet> myTransparencySortRebuildInSet;
    UT_UniquePtr<RV_ShaderVariableSet> myTransparencySortRebuildOutSet;
    UT_UniquePtr<RV_VKBuffer> myTransparencySourceIndexBuffer;
    UT_UniquePtr<RV_VKBuffer> myTransparencyVertexIndexBuffer;
    UT_UniquePtr<RV_VKBuffer> myTransparencySortKeysBuffer;
    UT_UniquePtr<RV_VKBuffer> myTransparencySortPrimitiveBuffer;
    UT_UniquePtr<RV_VKBuffer> myTransparencySortedIndexBuffer;
    UT_UniquePtr<GR_Utils::RadixSortGPU> myTransparencyRadixSort;
    UT_Int32Array        myTransparencySortIndices;
    exint                myTransparencySortPrimitiveCount = 0;

    static UT_Map<exint, RV_ShaderProgram *> theProgramMap;
};

#endif