GU_Blend.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_Blend.h (C++)
 *
 * COMMENTS:    Functions for blending between details.
 *
 */
 
 
 #ifndef __GU_BLEND_H__
#define __GU_BLEND_H__

#include "GU_API.h"
#include <GA/GA_Names.h>
#include <GA/GA_Types.h>
#include <UT/UT_Array.h>

class UT_StringRef;
class GU_Detail;
class GA_Attribute;
class GA_Group;
class GA_Range;

enum class GU_VoxelBlend
{
    None,
    ByGridIndex,
    ByVoxelPos,
    Advected
};

enum class GU_MaskMode
{
    None,
    SetFromAttrib,
    ScaleFromAttrib
};

namespace GU_Blend
{
struct PerAttribData
{
    UT_Array<UT_Array<float>> myArrayOfDeltas;
    UT_Array<UT_Array<int>> myArrayOfPageOffsets;
    UT_Array<UT_Array<std::pair<GA_PageNum,exint>>> myArrayOfPageStarts;
    UT_Array<int64> myArrayOfDataId;
};

struct PerMappingData
{
    UT_Array<GA_Offset> myArrayOfOffsets;
    bool myHasIdAttribMapping = false;
    bool myIdAttribDataIdIsSame = false;
};

struct MaskData
{
    GU_MaskMode myMode;
    UT_StringRef myAttribName;
    int mySource;
};

/// This cache can be used to accelerate successive blends.  However,
/// it is all references to *external* data.
/// It also does *NOT* detect if the id attribute names change, so the
/// caller is expected to clear the cache in that case.
class CachedItems
{
public:
    UT_Array<PerAttribData> *myPtArrayOfPerAttribData = NULL;
    UT_Array<PerAttribData> *myPrimArrayOfPerAttribData = NULL;
    UT_Array<PerAttribData> *myVertexArrayOfPerAttribData = NULL;
    UT_Array<PerMappingData> *myPtArrayOfPerMappingData = NULL;
    UT_Array<PerMappingData> *myPrimArrayOfPerMappingData = NULL;
    UT_Array<int64> *myPtTopoDataIds = NULL;
    UT_Array<int64> *myPrimListDataIds = NULL;
    int64 *myPtIdDataId = NULL;
    int64 *myPrimIdDataId = NULL;
};
}

/// If deleteUnmatched is true, points that don't have a match to interpolate with are deleted.
/// If deleteUnmatched is false but unmatchedGroupName is given (non-NULL), then these points
/// are instead put into a point group of the specified name.
/// Note that points of volume and VDB primitives are neither deleted nor put into the group.
GU_API void GUblend(
    GU_Detail *dest, const GU_Detail *source, fpreal weight,
    const char *pattern = "*", const UT_StringRef &ptidattr = GA_Names::id, const UT_StringRef &primidattr = GA_Names::name,
    bool doslerp = true, bool usevforpinterp = false, float timestep = (1/24.0),
    GU_VoxelBlend dovoxel = GU_VoxelBlend::None, GU_Blend::CachedItems *cached_items = NULL, const char *velname = "vel",
    float advdt = 1, bool deleteUnmatched = false, const char *unmatchedGroupName = NULL);

/// If deleteUnmatched is non-zero, points that have fewer than that many interpolation sources
/// are deleted from the output (or put into the specified group if unmatchedGroupName is not
/// NULL).
/// NOTE: Advected volume interpolation is necessarily linear; in that case, volweight is needed to determine
/// which detail to blend with and by how much.
GU_API void GUblend(
    GU_Detail *dest, const GU_Detail *gdps[], const float *weights, int size, const GA_Group *group,
    const char *pattern = "*", const UT_StringRef &ptidattr = GA_Names::id, const UT_StringRef &primidattr = GA_Names::name,
    bool doslerp = true, GU_VoxelBlend dovoxel = GU_VoxelBlend::None, GU_Blend::CachedItems *cached_items = NULL,
    bool is_differencing = true, bool dosparse = false,
    float timestep = (1/24.0), const char *velname = "vel", float advdt = 1, fpreal volweight = 0,
    int deleteUnmatched = 0, const char *unmatchedGroupName = NULL,
    const GU_Blend::MaskData * mask_data = NULL,
    float total = 1);

/// Blend the attribute values for the given range, with an optional mapping to
/// different offsets in the second detail.
/// If set, the weights and mapping arrays should be at least as long as attrib0's offset
/// map (attrib0.getIndexMap().offsetSize()).
/// @{
GU_API void GUblendRange(
        GA_Attribute &attrib0,
        const GA_Attribute &attrib1,
        const GA_Range &range0,
        float weight,
        const UT_Array<GA_Offset> *mapping);

GU_API void GUblendRange(
        GA_Attribute &attrib0,
        const GA_Attribute &attrib1,
        const GA_Range &range0,
        const UT_Array<float> &weights,
        const UT_Array<GA_Offset> *mapping);
/// @}

/// Calculate the blend weight for an in-between shape given the channel weight
/// and a list of all in-between weights
GU_API float GUgetInbetweenWeight(
    float channel_weight,
    const UT_Array<float> &inbetween_weights,
    int inbetween_idx);
#endif