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

#ifndef __GU_HIERARCHY_H_INCLUDED__
#define __GU_HIERARCHY_H_INCLUDED__

#include "GU_API.h"

#include "GU_AgentClip.h"

#include <GA/GA_Types.h>
#include <UT/UT_Array.h>
#include <UT/UT_BitArray.h>
#include <UT/UT_Map.h>
#include <UT/UT_Set.h>
#include <UT/UT_StringArray.h>
#include <UT/UT_StringHolder.h>
#include <UT/UT_StringSet.h>
#include <UT/UT_ValArray.h>
#include <UT/UT_VectorTypes.h>


class GA_PointGroup;
class GU_Detail;

namespace GU_Hierarchy
{
GU_API GA_Offset getParent(const GU_Detail *gdp, const GA_Offset &node);
GU_API GA_Offset getParentVertex(const GU_Detail *gdp, const GA_Offset &node);
GU_API void getParents(const GU_Detail *gdp, const GA_Offset &node, GA_OffsetArray &children);
GU_API void getParents(const GU_Detail *gdp, const GA_Offset &node, UT_Set<GA_Offset> &children);

GU_API GA_OffsetArray getChildren(const GU_Detail *gdp, const GA_Offset &node, bool recurse=false);
GU_API void getChildren(const GU_Detail *gdp, const GA_Offset &node, GA_OffsetArray &children, bool recurse=false);
GU_API void getChildren(const GU_Detail *gdp, const GA_Offset &node, UT_Set<GA_Offset> &children, bool recurse=false);

enum class ComputeHierarchyResult
{
    Success = 0,
    NoRoots,
    BadRoot,
    FoundCycle,
    IncompleteTraversal
};

/// Returns a descriptive message for the ComputeHierarchyResult.
GU_API const UT_StringHolder &getComputeHierarchyMessage(
        ComputeHierarchyResult result);

GU_API ComputeHierarchyResult traverse(
        const GU_Detail *gdp,
        GA_OffsetArray &roots,
        GA_OffsetArray &nodes,
        GA_OffsetArray &parents,
        UT_Map<GA_Offset, GA_OffsetArray> *children = nullptr);

GU_API bool findRoots(const GU_Detail *gdp, GA_OffsetArray &roots);

GU_API void computeLocalTransform(
        const GU_Detail *gdp,
        const GA_OffsetArray &nodes,
        const GA_OffsetArray &parents,
        const UT_Vector3DArray &P,
        const UT_Matrix3DArray &transform,
        UT_Matrix4DArray &local,
        UT_Matrix4DArray &effective_local,
        const UT_IntArray &model);

GU_API void computeWorldTransform(
        const GU_Detail *gdp,
        const GA_OffsetArray &nodes,
        const GA_OffsetArray &parents,
        UT_Vector3DArray &P,
        UT_Matrix3DArray &transform,
        const UT_Matrix4DArray &local,
        UT_Matrix4DArray &effective_local,
        const UT_IntArray &model,
        const GA_PointGroup *constrain_grp,
        const UT_Array<int> *flags,
        bool constrain_all);

} // namespace GU_Hierarchy

class GU_API GU_HierarchyCache
{
public:
    GU_HierarchyCache();

    bool rebuild(const GU_Detail *gdp, bool &topo_changed);
    void clear();
    bool worldTransformDirty(const GU_Detail *gdp);
    bool localTransformDirty(const GU_Detail *gdp);
    void initTransformData(const GU_Detail *gdp);
    void updateLocalTransformCache(const GU_Detail *gdp);
    void updateTransformCache(const GU_Detail *gdp, bool update_names=true);
    void updateTransformDataIds(const GU_Detail *gdp);

    int lookUpPointIndex(GA_Index ptidx) const;
    void computeLocalTransform(const GU_Detail *gdp);
    void computeWorldTransform(const GU_Detail *gdp);
    void computeWorldTransform(const GU_Detail *gdp,
        const GA_PointGroup *constrain_grp,const UT_Array<int> *flags,
        bool constrain);
    
    void clearSubHier();
    void updateSubHier();
    void appendSubHierLeaf(const GU_Detail *gdp, GA_Offset leaf_ptoff);
    void computeSubHierLocalTransform(const GU_Detail *gdp);
    void computeSubHierWorldTransform(const GU_Detail *gdp);
    void computeSubHierWorldTransform(const GU_Detail *gdp,
        const GA_PointGroup *contrain_grp, const UT_Array<int> *flags,
        bool constrain);

    // Apply a world transform to all the joints
    void transform(const UT_Matrix4D &m);

    // Apply a world transform to all the joints, but one
    void transform(const UT_Matrix4D &m, exint ignore_index);

    // Apply a transform to the local transform of all the root joints.
    void transformLocalRoots(const UT_Matrix4D &m);

    // Blend transforms using local space from another GU_HierarchyCache
    // using a weight.
    void blendLocalTransforms(const GU_HierarchyCache &hc, fpreal w,
        const GA_PointGroup *grp=nullptr,
        bool use_names=false);

    // Blend transforms using global space from another GU_HierarchyCache
    // using a weight.
    void blendWorldTransforms(const GU_HierarchyCache &hc, fpreal w,
        const GA_PointGroup *grp=nullptr,
        bool use_names=false);

    // Blend transforms using a rest pose space from another GU_HierarchyCache
    // using a weight.
    void blendRestTransforms( const GU_HierarchyCache &hc, fpreal w,
        const GU_HierarchyCache &rest,
        const GA_PointGroup *grp=nullptr,
        bool use_names=false);

    // Copy transforms back to P,transform,localtransform attributes on a detail.
    void copyTransforms(GU_Detail *gdp,
        bool copy_P=true,
        bool copy_transform=true,
        bool copy_localtransform=true);

    void update(const GU_HierarchyCache &hc);

public:
    GA_DataId myTopologyDataId;
    GA_DataId myPDataId;
    GA_DataId myTransformDataId;
    GA_DataId myLocalDataId;
    GA_DataId myNameDataId;
    GA_OffsetArray myRoots;
    GA_OffsetArray myNodes;
    GA_OffsetArray myParents;

    UT_Matrix4DArray myLocal;
    UT_Matrix3DArray myTransform;
    UT_Vector3DArray myP;
    UT_IntArray myModel;
    UT_Matrix4DArray myEffectiveLocal;

    UT_Array<GU_AgentXformD> myAgentXformsLocals;

    UT_StringHolder myNamesFormat;
    UT_StringArray myNames; // Point Name values
    UT_StringArray myIndexNames; // Variable names for the point name index variable
    UT_StringArray myNameNames;  // Variable names for the point name name variable
    UT_StringMap<GA_Index> myNamesMap; // for lookups to know if a point name appears more than once.
    UT_BitArray    myNamesValid; // tell has a unique name.
    UT_Array<UT_StringArray> myNamesArray; //Point Name values, as UT_StringArray


    GU_Hierarchy::ComputeHierarchyResult myTraverseResult;

private:

    UT_ValArray<int> myNodeLookup;

    UT_Array<bool> mySubHierarchy;
    GA_OffsetArray mySubHierarchyNodes;
    GA_OffsetArray mySubHierarchyParents;


    template <int HAS_GRP, int USE_NAME>
    SYS_FORCE_INLINE
    exint mapIndex(const GU_HierarchyCache &hc,
        const GA_PointGroup *grp, exint i);

    template <int HAS_GRP, int USE_NAME>
    SYS_FORCE_INLINE
    void blendLocalTransformsT(const GU_HierarchyCache &hc, fpreal w,
        const GA_PointGroup *grp=nullptr);

    template <int HAS_GRP, int USE_NAME>
    SYS_FORCE_INLINE
    void blendWorldTransformsT(const GU_HierarchyCache &hc, fpreal w,
        const GA_PointGroup *grp=nullptr);

    template <int HAS_GRP, int USE_NAME>
    SYS_FORCE_INLINE
    void blendRestTransformsT( const GU_HierarchyCache &hc, fpreal w,
        const GU_HierarchyCache &rest,
        const GA_PointGroup *grp=nullptr);
};

#endif // __GU_HIERARCHY_H_INCLUDED__