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

#ifndef __GT_PrimPatch__
#define __GT_PrimPatch__

#include "GT_API.h"
#include "GT_Primitive.h"

/// @brief A mesh of linear or cubic patches
class GT_API GT_PrimPatch : public GT_Primitive
{
public:
    GT_PrimPatch();
    GT_PrimPatch(const GT_PrimPatch &src)
        : GT_Primitive(src)
        , myVertex(src.myVertex)
        , myUniform(src.myUniform)
        , myDetail(src.myDetail)
        , myNu(src.myNu)
        , myNv(src.myNv)
        , myBasis(src.myBasis)
        , myUWrap(src.myUWrap)
        , myVWrap(src.myVWrap)
    {
    }
    GT_PrimPatch(const GT_PrimPatch &src,
                    const GT_AttributeListHandle &vertex,
                    const GT_AttributeListHandle &uniform,
                    const GT_AttributeListHandle &detail)
        : GT_Primitive(src)
        , myVertex(vertex)
        , myUniform(uniform)
        , myDetail(detail)
        , myNu(src.myNu)
        , myNv(src.myNv)
        , myBasis(src.myBasis)
        , myUWrap(src.myUWrap)
        , myVWrap(src.myVWrap)
    {
    }
    GT_PrimPatch(GT_Basis basis, int nu, bool uwrap, int nv, bool vwrap,
                    const GT_AttributeListHandle &vertex,
                    const GT_AttributeListHandle &uniform,
                    const GT_AttributeListHandle &detail)
    {
        init(basis, nu, uwrap, nv, vwrap, vertex, uniform, detail);
    }
    ~GT_PrimPatch() override;

    const char         *className() const override { return "GT_PrimPatch"; }
    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;
    /// @}

    /// Construct a simple patch:
    /// - @c nu @n Number of columns
    /// - @c nv @n Number of rows
    /// - @c uwrap @n
    ///   Whether the patch is connected between the last and first columns.
    /// - @c vwrap @n
    ///   Whether the patch is connected between the last and first rows.
    /// - @c vertex @n Attribute data per vertex (nu * nv elements)
    /// - @c uniform @n Uniform values for patch faces.  The number of
    /// entries should be:
    ///  - Linear:  (nu + uwrapped - 1) * (nv + vwrapped - 1)
    bool        init(GT_Basis basis,
                    int nu, bool uwrap,
                    int nv, bool vwrap,
                    const GT_AttributeListHandle &vertex,
                    const GT_AttributeListHandle &uniform,
                    const GT_AttributeListHandle &detail);

    /// @{
    /// Construct a curve mesh from a patch of vertices
    static GT_PrimitiveHandle   makePatchRows(GT_Basis basis,
                                    int nu, bool uwrap,
                                    int nv, bool vwrap,
                                    const GT_AttributeListHandle &vertex,
                                    const GT_AttributeListHandle &detail);
    static GT_PrimitiveHandle   makePatchCols(GT_Basis basis,
                                    int nu, bool uwrap,
                                    int nv, bool vwrap,
                                    const GT_AttributeListHandle &vertex,
                                    const GT_AttributeListHandle &detail);
    static GT_PrimitiveHandle   makePatchRowsCols(GT_Basis basis,
                                    int nu, bool uwrap,
                                    int nv, bool vwrap,
                                    const GT_AttributeListHandle &vertex,
                                    const GT_AttributeListHandle &detail);
    static GT_PrimitiveHandle   makePatchTriangles(
                                    int nu, bool uwrap,
                                    int nv, bool vwrap,
                                    const GT_AttributeListHandle &vertex,
                                    const GT_AttributeListHandle &detail);
    static GT_PrimitiveHandle   makePatchAlternatingTriangles(
                                    int nu, bool uwrap,
                                    int nv, bool vwrap,
                                    const GT_AttributeListHandle &vertex,
                                    const GT_AttributeListHandle &detail);
    static GT_PrimitiveHandle   makePatchReverseTriangles(
                                    int nu, bool uwrap,
                                    int nv, bool vwrap,
                                    const GT_AttributeListHandle &vertex,
                                    const GT_AttributeListHandle &detail);
    /// @}

    /// @{
    /// Accessor
    GT_Basis            getBasis() const        { return myBasis; }
    int                 getNu() const           { return myNu; }
    int                 getNv() const           { return myNv; }
    bool                getUWrap() const        { return myUWrap; }
    bool                getVWrap() const        { return myVWrap; }
    const GT_AttributeListHandle &getVertex() const     { return myVertex; }
    const GT_AttributeListHandle &getUniform() const    { return myUniform; }
    const GT_AttributeListHandle &getDetail() const     { return myDetail; }
    int                 getNuWrapped() const { return myUWrap ? myNu+1 : myNu; }
    int                 getNvWrapped() const { return myVWrap ? myNv+1 : myNv; }
    /// @}

    /// Harden all attributes so there are no dangling dependencies
    GT_PrimitiveHandle  doHarden() const override;
    GT_PrimitiveHandle  doSoftCopy() const override
                                    { return new GT_PrimPatch(*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    &getUniformAttributes() const override
                                                    { return myUniform; }
    const GT_AttributeListHandle    &getDetailAttributes() const override
                                                    { return myDetail; }
    /// @}

    /// Refine to a single polygon mesh.
    bool        refineToPolyMesh(GT_Refine &refine,
                            const GT_RefineParms *parms=NULL) const;
private:
    GT_AttributeListHandle      myVertex;
    GT_AttributeListHandle      myUniform;
    GT_AttributeListHandle      myDetail;
    int                         myNu, myNv;
    GT_Basis                    myBasis;
    bool                        myUWrap, myVWrap;
};

#endif