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 <RE/RE_ShaderHandle.h>
#include <UT/UT_Map.h>

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

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                getVkDecorGeometry(GR_DecorationRender::
                                    PrimitiveType prim_type,
                                    RV_PrimType render_prim,
                                    RV_Geometry &geo,
                                    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                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; }

    // 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; }

    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 updateAccelerationStructure(RV_Render* r,
                                     int tag,
                                     int light_id,
                                     const UT_Matrix4F &obj_mat) override;
    RV_VKAccelerationStructure* getAccelerationStructure() override;
   
private:
    
    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,
                                       const 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);
    void                generateNormalsGPU(RV_Render *r,
                                           const GR_DisplayOption &opts);


    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_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                myHasNormalOffsets = false;
    bool                myRanDisplacement = false;
    int                 myNumBlendShapes = 0;
    int                 myNumBoneTransforms = 0;

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

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

    UT_UniquePtr<RV_VKBuffer>          myNormalScratchBuffer;
    UT_UniquePtr<RV_ShaderVariableSet> myNormalGenSet;
    UT_UniquePtr<RV_ShaderVariableSet> myNormalMergeSet;

    UT_UniquePtr<RV_ShaderVariableSet> myTessellateInSet;
    UT_UniquePtr<RV_ShaderVariableSet> myTessellateOutSet;

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

#endif