GT_PrimPolygonMesh.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:        GT_PrimPolygonMesh.h ( GT Library, C++)
 *
 * COMMENTS:
 */

#ifndef __GT_PrimPolygonMesh__
#define __GT_PrimPolygonMesh__

#include "GT_API.h"
#include "GT_Primitive.h"
#include "GT_CountArray.h"
#include "GT_FaceSetMap.h"
#include "GT_AttributeMerge.h"
#include <GA/GA_Names.h>

class GT_DataArray;
class GT_PrimPolygon;
class GT_AttributeList;
class UT_StringRef;

/// Note this is all just copied from GEO_Normal
#define GT_DEFAULT_CUSP_ANGLE 60.0

/// Magic tolerance factor of 1.001 on GT_DEFAULT_CUSP_ANGLE so that
/// hexagonal tubes will be smooth by default, even with a bit of roundoff
/// or slight deformation.
#define GT_DEFAULT_ADJUSTED_CUSP_ANGLE 60.06

/// @brief A mesh of polygons
class GT_API GT_PrimPolygonMesh : public GT_Primitive
{
public:
    /// Default constructor
    GT_PrimPolygonMesh()
        : myVMerge()
        , myUMerge()
        , myConvexFlag(false)
    {
    }
    /// Useful constructor
    GT_PrimPolygonMesh(const GT_DataArrayHandle &vtx_counts,
                        const GT_DataArrayHandle &vtx_indices,
                        const GT_AttributeListHandle &shared,
                        const GT_AttributeListHandle &vertex,
                        const GT_AttributeListHandle &uniform,
                        const GT_AttributeListHandle &detail,
                        GT_IndexingMode indexing=GT_INDEXING_QUICK,
                        GT_Size min_vertex_count=0,
                        GT_Size max_vertex_count=0)
        : myVMerge()
        , myUMerge()
        , myConvexFlag(false)
    {
        init(vtx_counts, vtx_indices, shared, vertex, uniform, detail,
                    indexing, min_vertex_count, max_vertex_count);
    }

    GT_PrimPolygonMesh(const GT_CountArray &vtx_counts,
                        const GT_DataArrayHandle &vtx_indices,
                        const GT_AttributeListHandle &shared,
                        const GT_AttributeListHandle &vertex,
                        const GT_AttributeListHandle &uniform,
                        const GT_AttributeListHandle &detail)
        : myVMerge()
        , myUMerge()
        , myConvexFlag(false)
    {
        init(vtx_counts, vtx_indices, shared, vertex, uniform, detail);
    }

    /// Copy the topology information from the source pmesh, but use different
    /// attribute lists.
    GT_PrimPolygonMesh(const GT_PrimPolygonMesh &pmesh,
                       const GT_AttributeListHandle &shared,
                       const GT_AttributeListHandle &vertex,
                       const GT_AttributeListHandle &uniform,
                       const GT_AttributeListHandle &detail);

    /// Create a new polygon mesh with re-mapped vertices (used by
    /// removeUnusedPoints).
    ///
    /// Since the polygon faces are remapped you'll have to pass in a new face
    /// set map.
    GT_PrimPolygonMesh(const GT_PrimPolygonMesh &pmesh,
                       const GT_DataArrayHandle &vtx_indices,
                       const GT_AttributeListHandle &shared);

    /// Copy c-tor
    GT_PrimPolygonMesh(const GT_PrimPolygonMesh &pmesh);

    /// Construct a polygon mesh from a GT_PrimPolygon
    GT_PrimPolygonMesh(const GT_PrimPolygon &poly);

    const char *className() const override { return "GT_PrimPolygonMesh"; }
    bool        save(UT_JSONWriter &w) const override;

    /// @{
    /// Methods defined on GT_Primitive
    void        enlargeBounds(UT_BoundingBox boxes[],
                              int nsegments) const override;
    int         getPrimitiveType() const override;
    bool        refine(GT_Refine &refiner,
                       const GT_RefineParms *parms) const override;
    int         getMotionSegments() const override;
    int64       getMemoryUsage() const override;
    /// @}

    /// @{
    /// Initialize the mesh
    /// - @c vtx_counts @n
    ///   An integer array, representing the number of vertices in each face.
    ///   The length of the array determines the number of faces in the mesh.
    /// - @c vtx_indices @n
    ///   An array of vertex references.  There is an entry for every vertex in
    ///   every face.  These indices refer to the shared attribute data.
    /// - @c shared @n
    ///   Shared attribute data.  This data is referenced by the vertex arrays.
    /// - @c vertex @n
    ///   Unique data per vertex.  The length of these attribute arrays should
    ///   be the same as the length of the vtx_indices array.
    /// - @c uniform @n
    ///   Attribute per face.  There should be one entry for each entry in the
    ///   @c vtx_counts array.
    /// - @c detail @n
    ///   Constant attribute for all faces.
    ///   @c vtx_counts array.
    /// - @c indexing @n
    ///   What type of indexing is required
    void                init(const GT_DataArrayHandle &vtx_counts,
                             const GT_DataArrayHandle &vtx_indices,
                             const GT_AttributeListHandle &shared,
                             const GT_AttributeListHandle &vertex,
                             const GT_AttributeListHandle &uniform,
                             const GT_AttributeListHandle &detail,
                             GT_IndexingMode indexing=GT_INDEXING_QUICK,
                             GT_Size min_vertex_count=0,
                             GT_Size max_vertex_count=0);
    void                init(const GT_CountArray &vtx_counts,
                             const GT_DataArrayHandle &vtx_indices,
                             const GT_AttributeListHandle &shared,
                             const GT_AttributeListHandle &vertex,
                             const GT_AttributeListHandle &uniform,
                             const GT_AttributeListHandle &detail);
    /// @}

    /// Return the number of faces in the mesh
    GT_Size                     getFaceCount() const;
    /// Return a pointer to the individual face
    GT_PrimitiveHandle          getFace(GT_Offset i) const;

    /// Return the number of vertices
    GT_Size                     getVertexCount() const
    {
        return myVertexList ? myVertexList->entries() : 0;
    }
    /// Return the number of points
    GT_Size                     getPointCount() const
    {
        return myShared ? myShared->get(0)->entries() : 0;
    }

    /// @{
    /// Query the minimum/maximum number of vertices per face
    GT_Size     getMinVertexCount() const { return myFaceOffsets.getMinCount();}
    GT_Size     getMaxVertexCount() const { return myFaceOffsets.getMaxCount();}
    /// @}

    /// @{
    /// Accessor
    const GT_DataArrayHandle    &getVertexList() const override
                                    { return myVertexList; }
    const GT_CountArray         &getFaceCountArray() const
                                    { return myFaceOffsets; }
#if 0
    const GT_DataArrayHandle    &getFaceOffsets() const
                                    { return myFaceOffsets; }
#endif
    const GT_AttributeListHandle &getShared() const
                                    { return myShared; }
    const GT_AttributeListHandle &getVertex() const
                                    { return myVertex; }
    const GT_AttributeListHandle &getUniform() const
                                    { return myUniform; }
    const GT_AttributeListHandle &getDetail() const
                                    { return myDetail; }
    /// @}

    /// @{
    /// Access to the point sets
    const GT_ElementSetMapPtr   &pointSetMap() const { return myPointSetMap; }
    void                         setPointSetMap(const GT_ElementSetMapPtr &v)
                                        { myPointSetMap = v; }
    void                         addPointSet(const UT_StringHolder &name,
                                        const GT_ElementSetPtr &set);
    /// @}

    /// @{
    /// Access to the face sets
    const GT_ElementSetMapPtr   &faceSetMap() const     { return myFaceSetMap; }
    void                         setFaceSetMap(const GT_ElementSetMapPtr &v)
                                        { myFaceSetMap = v; }
    void                         addFaceSet(const UT_StringHolder &name,
                                        const GT_ElementSetPtr &set);
    /// @}

    /// Harden all attributes so there are no dangling dependencies
    GT_PrimitiveHandle          doHarden() const override;
    GT_PrimitiveHandle          doSoftCopy() const override
                                    { return new GT_PrimPolygonMesh(*this); }

    /// The virtual implementation of attribute merging
    GT_PrimitiveHandle          doAttributeMerge(
                                        const GT_Primitive &src,
                                        const UT_StringMMPattern *vertex,
                                        const UT_StringMMPattern *point,
                                        const UT_StringMMPattern *uniform,
                                        const UT_StringMMPattern *detail
                                        ) const override;

    /// @{
    /// Access attributes
    const GT_AttributeListHandle    &getVertexAttributes() const override
                                        { return myVertex; }
    const GT_AttributeListHandle    &getPointAttributes() const override
                                        { return myShared; }
    const GT_AttributeListHandle    &getUniformAttributes() const override
                                        { return myUniform; }
    const GT_AttributeListHandle    &getDetailAttributes() const override
                                        { return myDetail; }
    /// @}

    /// Return the point index for a given face and vertex
    GT_Offset getPoint(GT_Offset face, GT_Offset v) const;

    /// Return the offset into the vertex list for the given face
    GT_Offset           getVertexOffset(GT_Offset face) const
                            { return myFaceOffsets.getOffset(face); }
    /// Return the length of the vertex list for the given face
    GT_Size             getVertexCount(GT_Offset face) const
                            { return myFaceOffsets.getCount(face); }
    /// For a given face, find the shared point numbers for the given vertex
    /// and the next vertex (i.e. the edge starting from the given vertex).
    void                getEdgePoints(GT_Offset face, GT_Offset vertex,
                                GT_Offset &p0, GT_Offset &p1) const;

    /// Returns true if this mesh has been convexed
    bool                isConvexed() const { return myConvexFlag; }

    /// Set the convex flag on the mesh
    void                setConvexed(bool c) { myConvexFlag = c; }

    /// Return an array containing the face counts per-face
    GT_DataArrayHandle
                getFaceCounts(GT_IndexingMode indexing=GT_INDEXING_QUICK) const;

    /// The polygon mesh may have shared points which aren't used.  That is,
    /// there may be elements in the shared element list which aren't
    /// referenced by any vertex.  This method will build a list of indices for
    /// all the used points.
    ///
    /// The list returned will be monotonically ascending.
    const GT_DataArrayHandle
                getUsedPointList(GT_IndexingMode idx=GT_INDEXING_QUICK) const;

    /// Ensure all polygons in the mesh are convex
    ///
    /// If the @c holes set is passed in, then the faces in that set will be
    /// excluded from the convexed result.
    GT_PrimitiveHandle          convex(int max_points_per_poly=3,
                                       bool keep_degenerate = false,
                                       bool allow_interrupt = true,
                                       bool allow_indirect_flattening = false,
                                       const UT_Set<int> *holes = nullptr) const;

    /// Using the indirect arrays and vertex list from a convexed mesh,
    /// convex this mesh (assumes topology is the same).
    GT_PrimitiveHandle          adoptConvexing(
                                    const GT_DataArrayHandle &verts,
                                    const GT_DataArrayHandle &uniform_indexing,
                                    const GT_DataArrayHandle &vertex_indexing,
                                    const GT_DataArrayHandle &vert_info,
                                    const GT_DataArrayHandle &prim_info,
                                    bool allow_indirect_flattening=false)
                                const;

    /// Fetches the convexed arrays from the mesh, to be used by adoptConvexing
    /// on a different mesh with the same topology. `base` is the original mesh
    /// before convexing, used to avoid returning indexing arrays that weren't
    /// added by the convex function.
    void                        getConvexArrays(
                                    GT_DataArrayHandle &verts,
                                    GT_DataArrayHandle &uniform_indexing,
                                    GT_DataArrayHandle &vertex_indexing,
                                    GT_DataArrayHandle &point_indexing,
                                    GT_DataArrayHandle &vert_info,
                                    GT_DataArrayHandle &prim_info,
                                    const GT_PrimPolygonMesh* base = nullptr) const;

    /// Remove unused points.  This will collapse the varying point arrays,
    /// leaving only the points referenced by the vertices.
    UT_IntrusivePtr<GT_PrimPolygonMesh> removeUnusedPoints(
                                        const int32 *idx=nullptr) const;

    /// @{
    /// Compute face normals.  This will use the shared attribute named P to
    /// compute the normals for each face.
    /// fpreal16 must have the proper vector length
    bool                        faceNormals(UT_Vector3 *N,
                                        int segment=0,
                                        const UT_StringRef &P=GA_Names::P) const;
    bool                        faceNormals(UT_Vector3D *N64,
                                        int segment=0,
                                        const UT_StringRef &P=GA_Names::P) const;
    bool                        faceNormals(fpreal16 *N16,
                                        int segment=0,
                                        const UT_StringRef &P=GA_Names::P) const;
    GT_DataArrayHandle          faceNormals(int segment=0,
                                        const UT_StringRef &P=GA_Names::P,
                                        GT_Storage store=GT_STORE_REAL32) const;
    /// @}

    /// @{
    /// Compute shared normals.  This will use the shared attribute named P to
    /// compute the normals for each shared point.
    bool                        pointNormals(UT_Vector3T<fpreal16> *N,
                                        GT_Size npts,
                                        int segment=0,
                                        const UT_StringRef &P=GA_Names::P,
                                        bool normalize=true,
                                        const fpreal32 *pntdata = nullptr) const;
    bool                        pointNormals(UT_Vector3 *N, GT_Size npts,
                                        int segment=0,
                                        const UT_StringRef &P=GA_Names::P,
                                        bool normalize=true,
                                        const fpreal32 *pntdata = nullptr) const;
    bool                        pointNormals(UT_Vector3D *N, GT_Size npts,
                                        int segment=0,
                                        const UT_StringRef &P=GA_Names::P,
                                        bool normalize=true,
                                        const fpreal32 *pntdata = nullptr) const;
    GT_DataArrayHandle          createPointNormals(int segment=0,
                                       const UT_StringRef &P=GA_Names::P,
                                       bool normalize=true,
                                       const fpreal32 *pntdata = nullptr,
                                       GT_Storage store =GT_STORE_REAL32
                                       ) const override;
    /// @}

    /// @{
    /// Compute vertex normals.  This will use the shared attribute named P to
    /// compute the normals for each vertex.
    bool                        vertexNormals(UT_Vector3T<fpreal16> *N,
                                        GT_Size npts,
                                        int segment=0,
                                        const UT_StringRef &P=GA_Names::P,
                                        fpreal maxangledegrees=GT_DEFAULT_ADJUSTED_CUSP_ANGLE,
                                        bool normalize=true) const;
    bool                        vertexNormals(UT_Vector3 *N,
                                        GT_Size npts,
                                        int segment=0,
                                        const UT_StringRef &P=GA_Names::P,
                                        fpreal maxangledegrees=GT_DEFAULT_ADJUSTED_CUSP_ANGLE,
                                        bool normalize=true) const;
    bool                        vertexNormals(UT_Vector3D *N,
                                        GT_Size npts,
                                        int segment=0,
                                        const UT_StringRef &P=GA_Names::P,
                                        fpreal maxangledegrees=GT_DEFAULT_ADJUSTED_CUSP_ANGLE,
                                        bool normalize=true) const;
    virtual GT_DataArrayHandle  createVertexNormals(int segment=0,
                                       const UT_StringRef &P=GA_Names::P,
                                       fpreal maxangledegrees=GT_DEFAULT_ADJUSTED_CUSP_ANGLE,
                                       bool normalize=true,
                                       GT_Storage store =GT_STORE_REAL32) const;
    /// @}


    /// @brief Create point normals on a new mesh if no normals are found.
    /// If no point or vertex normals are found, generate point normals from P
    /// and return a new mesh. If normals are found, return NULL.
    ///
    /// If the segement is less than 0, normals for *all* segments will be
    /// computed (if required)
    GT_PrimPolygonMesh *createPointNormalsIfMissing(
                                        const UT_StringRef &P=GA_Names::P,
                                        bool normalize=true,
                                        bool *error = nullptr) const;

    GT_PrimPolygonMesh *createVertexNormalsIfMissing(
                                        const UT_StringRef &P=GA_Names::P,
                                        fpreal cuspangledegrees=GT_DEFAULT_ADJUSTED_CUSP_ANGLE,
                                        bool normalize=true,
                                        bool *error = nullptr) const;

    /// Compress vertex normals to create an indexed array
    GT_PrimPolygonMesh  *compressVertexNormals(
                                        fpreal compression_ratio=1.0) const;

    /// Compress all attribute arrays
    GT_PrimPolygonMesh  *compressAttributes(const char *pattern="*,^P",
                                        fpreal compression_ratio=1.0) const;

    /// Create point normals and MikkT tangents on a new mesh if not found.
    /// If either normals or tangents are not found, return a new mesh with
    /// both generated. If both exist, return NULL.
    GT_PrimPolygonMesh *createTangentsIfMissing(bool *error = nullptr);

    /// Create quick tangents (not MikkT) for fast viewer tangent generation.
    /// Tangents are not created in this mesh.
    ///  NOTE: Not working very well yet.
    bool        createFastTangents(GT_DataArrayHandle *tanu_h,
                                   GT_DataArrayHandle *tanv_h) const;
    
    /// @brief Divide a mesh into smaller meshes if it exceeds the poly_limit.
    /// If this mesh has more than polygon_limit polygons, this will split the
    /// mesh into multiple sub-meshes, attempting to keep them all roughly the
    /// same number of polygons. If this mesh has fewer than polygon_limit
    /// polygons, it will return false and not add any meshes to split_meshes.
    /// If remove_unused_points is true, each submesh will have unused points
    /// removed.
    bool        splitMesh(GT_Size polygon_limit,
                          UT_Array<GT_PrimitiveHandle> &split_meshes,
                          bool remove_unused_points = true) const;

    /// Partition a mesh into submeshes by the shop_materialpath attribute,
    /// each with exact one material in a detail shop_materialpath attribute.
    /// Returns false if shop_materialpath doesn't exist, isn't a uniform attrib,
    /// or has only 1 material.
    bool        partitionByMaterial(const GT_DataArrayHandle &mat_id,
                                    UT_Array<GT_PrimitiveHandle> &sub_meshes,
                                    GT_Size polygon_limit = SYS_INT32_MAX) const;

    /// @{
    /// Methods for GEO/GU support.
    fpreal      computePerimeter(int seg) const override;
    fpreal      computeSurfaceArea(int seg) const override;
    fpreal      computeVolume(const UT_Vector3 &ref_P, int seg) const override;
    /// @}

    bool        updateGeoPrim(const GU_ConstDetailHandle &dtl,
                              const GT_RefineParms &refine) override;

protected:
    void        hardenAttributes();

    // We have "clone" methods so that sub-classes (i.e.
    // GT_PrimSubdivisionMesh) can create an appropriate clone.  These are used
    // by methods internal when duplicating the mesh (i.e. removeUnusedPoints)
    virtual GT_PrimPolygonMesh  *clone(const GT_DataArrayHandle &vtx_counts,
                        const GT_DataArrayHandle &vtx_indices,
                        const GT_AttributeListHandle &shared,
                        const GT_AttributeListHandle &vertex,
                        const GT_AttributeListHandle &uniform,
                        const GT_AttributeListHandle &detail,
                        GT_IndexingMode indexing=GT_INDEXING_QUICK,
                        GT_Size min_vertex_count=0,
                        GT_Size max_vertex_count=0) const
    {
        return new GT_PrimPolygonMesh(vtx_counts, vtx_indices,
                shared, vertex, uniform, detail, indexing,
                min_vertex_count, max_vertex_count);
    }
    virtual GT_PrimPolygonMesh  *clone(const GT_CountArray &vtx_counts,
                        const GT_DataArrayHandle &vtx_indices,
                        const GT_AttributeListHandle &shared,
                        const GT_AttributeListHandle &vertex,
                        const GT_AttributeListHandle &uniform,
                        const GT_AttributeListHandle &detail) const
    {
        return new GT_PrimPolygonMesh(vtx_counts, vtx_indices,
                shared, vertex, uniform, detail);
    }
    virtual GT_PrimPolygonMesh  *clone(const GT_AttributeListHandle &shared,
                       const GT_AttributeListHandle &vertex,
                       const GT_AttributeListHandle &uniform,
                       const GT_AttributeListHandle &detail) const
    {
        return new GT_PrimPolygonMesh(*this, shared, vertex, uniform, detail);
    }
    virtual GT_PrimPolygonMesh  *clone(const GT_DataArrayHandle &vtx_indices,
                       const GT_AttributeListHandle &shared) const
    {
        return new GT_PrimPolygonMesh(*this, vtx_indices, shared);
    }

    GT_AttributeListHandle       myShared;
    GT_AttributeListHandle       myVertex;
    GT_AttributeListHandle       myUniform;
    GT_AttributeListHandle       myDetail;

private:
    template <typename VECTOR_T>
    GT_DataArrayHandle           getVertexNormalHandle(
                                        const UT_StringRef &P_name,
                                        int seg,
                                        fpreal maxangledegrees,
                                        bool normalize) const;
    template <typename VECTOR_T>
    bool                         computePointNormals(
                                        UT_Vector3T<VECTOR_T> *N,
                                        GT_Size Nsize,
                                        const UT_StringRef &P,
                                        int segment,
                                        bool normalize,
                                        const fpreal32 *point_data) const;
    template <typename VECTOR_T>
    bool                         computeVertexNormals(
                                        UT_Vector3T<VECTOR_T> *N,
                                        GT_Size Nsize,
                                        const UT_StringRef &P,
                                        int segment,
                                        fpreal maxangledegrees,
                                        bool normalize) const;

    bool   createFastTangentsUV(const GT_DataArrayHandle &ph,
                                const GT_DataArrayHandle &uvh,
                                GT_Owner uv_owner,
                                GT_DataArrayHandle *tanuh,
                                GT_DataArrayHandle *tanvh) const;
    
    void                         makeMerge();

    GT_DataArrayHandle                  myVertexList;
    GT_CountArray                       myFaceOffsets;
    GT_ElementSetMapPtr                 myPointSetMap;
    GT_ElementSetMapPtr                 myFaceSetMap;
    UT_UniquePtr<GT_AttributeMerge>     myVMerge, myUMerge;
    bool                                myConvexFlag;
};

#endif