GR_OSDSubdData.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_OSDSubdData.C ( GR Library, C++)
 *
 * COMMENTS:
 *      Class for subdivision surface data shared between GL and Vulkan.
 */
#ifndef GR_OSDSubdData_h
#define GR_OSDSubdData_h

#include <GA/GA_EdgeGroup.h>
#include <GU/GU_DetailHandle.h>
#include <GT/GT_OSD3.h>
#include <GT/GT_UtilOpenSubdiv.h>

#include "GR_API.h"

#define ENABLE_FAS 0

class GR_UpdateParms;
class GR_PickRecord;

class GR_API GR_OSDSubdData
{
public:
    struct StencilData
    {
        int numStencils; 
        int numTotalStencilElements;
        UT_Array<int>   sizes;
        UT_Array<int>   offsets;
        UT_Array<int>   indices;
        UT_Array<float> weight;

        void reset()
        {
            sizes.clear();
            offsets.clear();
            indices.clear();
            weight.clear();
        }
    };

#if ENABLE_FAS
    struct PatchArray
    {
        uint patchType;
        uint cvPerPatch;
        uint numPatches;
        uint patchBase;
        uint patchIndicesBase;
    };

    struct PatchCoord
    {
        int arrayIndex;
        int patchIndex;
        int vertIndex;
        float s;
        float t;
    };

    using PatchParam = UT_Vector2T<uint>;

    struct PatchData
    {
        int numArrays;
        int numTotalPatches;
        UT_Array<PatchArray> patchArray;
        UT_Array<uint> patchIndices;
        UT_Array<UT_Vector2i> patchParams;
        UT_Array<PatchCoord> patchCoords;

        void reset()
        {
            patchArray.clear();
            patchIndices.clear();
            patchParams.clear();
        }
    };
#endif

public:
    void        preUpdate(const GT_PrimitiveHandle &primh,
                          GR_UpdateParms &p);
    
    bool        isReducedLOD() const { return myReducedLOD; }
    int         getSubdivisionLevel() const { return mySubdLevel; }
    const GT_PrimitiveHandle &surface() { return mySurface; }

    void        resetSubdivision();

    /* GPU implementation start */
    void                        createStaticOSDContext(
                                    const GT_PrimitiveHandle& primh,
                                    const GU_ConstDetailHandle &geometry,
                                    const uint subdiv_level,
                                    bool use_adaptive = false);

    const GT_PrimitiveHandle    getFullMeshPrimh() const
                                    { return myFullMeshPrimh; }

    void                        buildVertexStencilData();
    void                        buildFVarStencilData();
#if ENABLE_FAS
    const StencilData*          extractLocalPointStencilTableData();
    const PatchData*            extractPatchTableData();
#endif

    const StencilData*          getVertexStencilData() const
                                    { return &myVertexStencilData; }
    const StencilData*          getFVarStencilData() const
                                    { return &myFVarStencilData; }
    UT_Int32Array               extractVertexPointIndices(uint subdiv_level) const;
    UT_Int32Array               extractFVarVertexIndices(uint subdiv_level) const;
    UT_Int32Array               extractFaceParentIndices(uint subdiv_level) const;
    const UT_Array<uint>       &getAllPointVertices() const;
    const UT_Array<uint>       &getAllEdgeVertices() const;
    UT_Int32Array               extractAllPointCoarsePointIDs() const;
    UT_Int32Array               extractAllEdgeCoarsePointIDs() const;
    UT_Vector4iArray            extractAllEdgePrimInfo() const;

    UT_Array<uint>              extractPointVertices(
                                    const UT_Array<uint> &points) const;
    UT_Array<uint>              extractEdgeVertices(
                                    const UT_Array<uint> &edges) const;
    UT_Array<uint>              extractFaceVertices(
                                    const UT_Array<uint> &faces) const;

    /// Translate source detail primitive/point/edge indices into the coarse 
    /// OSD face/point/edge indices. The two spaces differ whenever the refined 
    /// mesh only holds a subset of the detail's primitives (for example when 
    /// some are hidden).
    bool                        mapPointIndexToCoarseVertex(
                                    uint point, uint &vertex) const;
    UT_Array<uint>              mapPrimIndicesToCoarseFaces(
                                    const UT_Array<uint> &prim_indices) const;
    UT_Array<uint>              mapPointIndicesToCoarseVertices(
                                    const UT_Array<uint> &point_indices) const;
    UT_Array<uint>              mapEdgePointPairsToCoarseVertices(
                                    const UT_Array<uint> &point_pairs) const;

    UT_Array<uint>              extractEdgeIndices(
                                    const UT_Array<uint>& edge_pair_vertices) const;
    bool                        getRefinedEdgeDrawRange(
                                    uint point0,
                                    uint point1,
                                    exint &draw_offset,
                                    exint &draw_size) const;

    UT_Int32Array               extractSharedIndexBuffer(uint subd_level) const;

    uint                        getNumFaces(uint subd_level) const;
    uint                        getNumEdges(uint subd_level) const;
    uint                        getNumVertices() const
                                    { return myNumVertices; }
    uint                        getNumFVarVertices() const
                                    { return myNumFVarVertices; }

protected:
    static UT_Int32Array        buildCoarsePrimIDs(
                                    const GT_PrimitiveHandle &primh,
                                    const GU_ConstDetailHandle &geometry,
                                    exint num_coarse_faces);
    static UT_Int32Array        buildCoarsePointIDs(
                                    const GT_PrimitiveHandle &primh,
                                    const GU_ConstDetailHandle &geometry,
                                    exint num_coarse_points);

private:
    void                        buildStencilData(const GT_OSDStencilTable& stencil_table,
                                                StencilData& stencil_table_data);
    /// extract the fine level edges from coarse level edges
    template <int BranchingFactor, typename ChildGetterFunc>
    void                        extractSubdComponents(
                                    UT_Array<UT_Array<uint>> &elements_per_level,
                                    ChildGetterFunc get_children) const;

    template <int BranchingFactor, typename VertexGetterFunc>
    UT_Array<uint>               extractSubdComponentVertices(
                                    const UT_Array<UT_Array<uint>> &elements_per_level,
                                    VertexGetterFunc get_vertices) const;

    void                        buildPrimIDToCoarseFaceMap(
                                    exint num_coarse_faces) const;
    void                        buildPointIDToCoarseVertexMap(
                                    exint num_coarse_points) const;

    GT_PrimitiveHandle  myFullMeshPrimh;
    GU_ConstDetailHandle myFullMeshGeometry;

    uint                myNumVertices;
    uint                myNumFVarVertices;
    
    GT_OSDOptions       myOSDOptions;
    GT_OSDTopology      myOSDTopology;

    GT_OSDStencilTable  myOSDVertexStencilTable;
    GT_OSDStencilTable  myOSDFVarStencilTable;

    StencilData         myVertexStencilData;
    StencilData         myFVarStencilData;

    mutable UT_Array<uint>  myAllPointVertices;
    mutable UT_Array<uint>  myAllEdgeVertices;
    mutable bool            myAllPointVerticesBuilt = false;
    mutable bool            myAllEdgeVerticesBuilt = false;

    mutable UT_Map<int32, uint> myPrimIDToCoarseFace;
    mutable bool                myPrimIDToCoarseFaceBuilt = false;
    mutable UT_Map<int32, uint> myPointIDToCoarseVertex;
    mutable bool                myPointIDToCoarseVertexBuilt = false;

#if ENABLE_FAS
    void        extractPatchArrays(const GT_OSDPatchTable& patch_table);
    void        extractPatchIndices(const GT_OSDPatchTable& patch_table);
    void        extractPatchParam(const GT_OSDPatchTable& patch_table);

    GT_OSDStencilTable  myOSDLocalPointStencilTable;
    GT_OSDPatchTable    myOSDPatchTable;

    StencilData    myLocalPointStencilData;
    PatchData      myPatchData;
#endif
    /* GPU implementation end */
    
    UT_UniquePtr<GT_UtilOpenSubdiv> myOsd;
    GT_PrimitiveHandle              mySurface;
    int64       myVertexAttributeDataIdHash = -1;
    bool        myReducedLOD = false;
    int         mySubdLevel = 0;
    int         myTopID = 0;
};

#endif