SOP_GroomUtils.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:        SOP Library (C++)
 *
 * COMMENTS:
 *      Helper classes for working with hair and fur grooms.
 */

#ifndef __SOP_GroomUtils_h__
#define __SOP_GroomUtils_h__

#include <GA/GA_AttributeRefMap.h>
#include <GEO/GEO_PointTree.h>
#include <GU/GU_Detail.h>
#include <UT/UT_LineTree.h>
#include <UT/UT_Ramp.h>
#include <UT/UT_Tuple.h>
#include <UT/UT_UniquePtr.h>
#include "SOP_NodeVerb.h"

// A tree that can be built using an arbitrary prim or point attribute as the
// point position. When using a prim attribute, this allows direct lookup of
// curve primitives.
class sop_CurveTree : public GEO_PointTreeGAOffset
{
public:
    /// Rebuilds the tree with the given detail and primitive group,
    /// This creates a point per primitive using the primitive attribute of the
    /// specified name as the point position.
    /// if primgroup is NULL then all primitives are used.
    void
    build(
        const GEO_Detail *gdp,
        const GA_PrimitiveGroup *primgroup,
        const char *attrib,
        bool enable_multithreading=true);

    // Methods that must delegate to base class due to overloads
    void build(
        const GEO_Detail *gdp,
        const GA_PointGroup *ptgroup,
        bool enable_multithreading = true)
    {
        GEO_PointTreeGAOffset::build(gdp, ptgroup, enable_multithreading);
    }

    void build(
        const GEO_Detail *gdp,
        const GA_PointGroup *ptgroup,
        const char *attrib,
        bool enable_multithreading = true)
    {
        GEO_PointTreeGAOffset::build(gdp, ptgroup, attrib, enable_multithreading);
    }
};

class sop_FastRamp
{
public:
    sop_FastRamp(int numsamples=1000)
    : numsamples(numsamples)
    {}

    bool update(const UT_Ramp *widthramp);

    float lookup(float u) const;

    float lookupNearest(float u) const;

private:
    UT_FloatArray samples;
    int numsamples;
};

class sop_SourceAttribList
{
public:
    sop_SourceAttribList(
        GU_Detail *dest,
        const GU_Detail *source,
        const GA_AttributeOwner destowner)
    : dest(dest)
    , source(source)
    , destowner(destowner)
    {}

    using AttribMatchTuple = std::pair<GA_AttributeOwner, UT_StringHolder>;

    void addSourceAttribs(
        const GA_AttributeOwner sourceowner,
        const char *matchpattern,
        UT_Set<AttribMatchTuple> &alreadymapped);

    enum AttribChange
    {
        NONE,
        DATA,
        STORAGE
    };

    class CacheData
    {
    private:
        UT_ValArray<int> targetindices;
        UT_ValArray<GA_AttributeOwner> owners;
        UT_ValArray<UT_StringHolder> names;
        UT_ValArray<int> typeids;
        UT_ValArray<int> tuplesizes;
        UT_ValArray<GA_DataId> dataids;

        friend sop_SourceAttribList;

    };

    void mapAndCreateAttribs(
        GA_AttributeRefMap &map) const
    {
        mapAndCreateAttribs(map, nullptr);
    }


    void mapAndCreateAttrib(
        GA_AttributeRefMap &map,
        const UT_ValArray<AttribChange> *changes,
        int index) const;

    void mapAndCreateAttribs(
        GA_AttributeRefMap &map,
        const UT_ValArray<AttribChange> *changes) const;

    void mapAndCreateRealAttribs(
        GA_AttributeRefMap &map,
        const UT_ValArray<AttribChange> *changes) const;

    void mapAndCreateNonRealAttribs(
        GA_AttributeRefMap &map,
        const UT_ValArray<AttribChange> *changes) const;

    bool updateCache(
            UT_UniquePtr<CacheData> &cachedata,
            UT_ValArray<AttribChange> &changes) const;

private:
    CacheData* getCacheData() const;

    const GU_Detail *source;
    UT_ValArray<const GA_Attribute*> sourceattribs;
    GU_Detail *dest;
    const GA_AttributeOwner destowner;
};

struct sop_PartingLineAttribs
{
    sop_PartingLineAttribs(
        const GU_Detail &gdp,
        const GA_ROHandleV3 &restattrib,
        const SOP_NodeVerb::CookParms &cookparms);

    bool attribMissing() { return myAttribMissing; }

    const GA_ROHandleV3     &rest;
    GA_ROHandleF             radius;
    GA_ROHandleF             strength;
    GA_ROHandleV3            normal;

private:
    bool myAttribMissing;
};

class sop_PartingLineLookup
{
public:
    struct PerThreadData
    {
        void setArraySize(unsigned int size)
        {
            lines.setSize(size);
            dist2s.setSize(size);
        }

        UT_IntArray          lines;
        UT_FloatArray        dist2s;
    };

    sop_PartingLineLookup(unsigned int maxpartlines)
    : myMaxPartLines(maxpartlines)
    {}

    static const GA_PrimitiveGroup*
    getGroup(const GU_Detail &gdp)
    {
        return gdp.findPrimitiveGroup("partinglines");
    }

    void
    setLines(
        const GU_Detail &gdp,
        const GA_ROHandleV3 &restattrib,
        const GA_PrimitiveGroup &partlinesgroup);

    float
    computePartingWeight(
        const UT_Vector3 &posA,
        const UT_Vector3 &posB,
        const sop_PartingLineAttribs &attribs,
        UT_ThreadSpecificValue<PerThreadData> &threadvalues) const;

private:
    const unsigned int myMaxPartLines;

    class sop_PartLineTree : public UT_LineTree
    {
    public:
        int addLine(const GA_Offset ptoff1, const UT_Vector3 &pt1,
                    const GA_Offset ptoff2, const UT_Vector3 &pt2);

        void setCapacity( unsigned capacity );

        GA_Offset getLineOffset1(int id) const
        { return myOffsets(2 * id); }

        GA_Offset getLineOffset2(int id) const
        { return myOffsets(2 * id + 1); }

    private:
        GA_OffsetArray myOffsets;
    };

    sop_PartLineTree             myLineTree;
};

uint sop_vexHash(float seed);
uint sop_vexHash(float seed1, float seed2);
float sop_vexRandom(uint seed);
float sop_vexRand(uint seed);

fpreal sop_calcPerimeter(UT_Vector3Array &pos);
float sop_unitLengthToUnitDomain(UT_Vector3Array &pos, float ulength);
float sop_unitToUnitLengthDomain(UT_Vector3Array &pos, float uparm);

void sop_skinPrimError(const SOP_NodeVerb::CookParms &cookparms);

#endif