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 <CE/CE_BufferDevice.h>
#include <CE/CE_Context.h>
#include <GA/GA_CEAttribute.h>
#include <GA/GA_IndexMap.h>
#include <GA/GA_Names.h>
#include <GA/GA_Types.h>
#include <UT/UT_Array.h>
#include <UT/UT_UniquePtr.h>
#include <SYS/SYS_Types.h>

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

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;
};
template <typename T>
struct PerAttribDataT
{
    UT_Array<UT_Array<T>> 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;
};

// OpenCL delta mode
enum DeltaModeOCL : uint8_t
{
    DENSE_MODE,
    SPARSE_MODE
};

// Compressed Sparse 
struct SparseHeader
{
    exint shapeID;
    GA_PageNum pageNum;
    exint start;
    exint count;
};

class CachedItemsOCL
{
public:
    GU_API CachedItemsOCL();

    GU_API void initPerFrameOCL(
            bool use_opencl,
            const GA_IndexMap *index_map,
            DeltaModeOCL dense_mode = DENSE_MODE);

    void clearOCL();

    void prepareSparseDeltasOCL(
            const UT_Array<UT_Array<float>> &cpu_deltas,
            const UT_Array<UT_Array<int>> &page_offsets,
            const UT_Array<UT_Array<std::pair<GA_PageNum, exint>>> &page_starts,
            int num_shapes,
            int tuple_size);

    void prepareDenseDeltasOCL(
        const UT_Array<UT_Array<float>> &cpu_deltas,
        const UT_Array<UT_Array<int>> &page_offsets,
        const UT_Array<UT_Array<std::pair<GA_PageNum, exint>>> &page_starts,
        int num_shapes,
        int tuple_size);

    void prepareWeightsOCL(const float *cpu_weights, int num_shapes);

    void setCopyKernelArgOCL(GA_Attribute *data_attrib, int num_tuples);
    void setSparseKernelArgOCL(GA_Attribute *data_attrib, int num_tuple);
    void setDenseKernelArgOCL(
            GA_Attribute *data_attrib,
            int num_tuples,
            int num_shapes);

    void applyCopyKernelOCL(GA_Attribute *data_attrib, int num_tuples);
    void applySparseDeltaOCL(
            GA_Attribute *data_attrib,
            int num_shape,
            int num_tuple);
    void applyDenseDeltaOCL(
            GA_Attribute *data_attrib,
            int num_shapes,
            int num_tuples);

    void setRedoDeltaOCL(bool redo_delta) { myRedoDelta = redo_delta; }

    bool useOCL()               { return myUseOCL; }
    bool isInitOCL()            { return myInitOCL; }
    DeltaModeOCL deltaModeOCL() { return myDeltaModeOCL; }
    bool switchDeltaModeOCL()   { return mySwitchDeltaModeOCL; }
    bool redoDelta()            { return myRedoDelta; }
    bool isDeltaBufferEmpty()   { return myIsDeltaEmpty; }

private:
    bool myUseOCL;
    bool myInitOCL;
    DeltaModeOCL myDeltaModeOCL;
    bool mySwitchDeltaModeOCL;
    bool myRedoDelta;
    bool myIsDeltaEmpty;

    GA_DataId mySrcDataID;
    exint myNpts;
    exint myNumHeaders;

    const GA_IndexMap *myPtMap;

    cl::Program myOCLProgram;
    cl::Kernel myApplyDeltaKernel;

    GA_CEAttributePtr mySrcCEAttrib;
    GA_CEAttributeAccessorPtr mySrcCEAccessorPtr;

    CE_BufferDevice<float> myDeltasBuffer;
    CE_BufferDevice<SparseHeader> myCSHeadersBufffer;
    CE_BufferDevice<int> myPointIndicesBuffer;
    CE_BufferDevice<float> myWeightsBuffer;
};

/// 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;
    CachedItemsOCL *myCachedItemsOCL = NULL;
};
template <typename T>
class CachedItemsT
{
public:
    UT_Array<PerAttribDataT<T>> *myPtArrayOfPerAttribData = NULL;
    UT_Array<PerAttribDataT<T>> *myPrimArrayOfPerAttribData = NULL;
    UT_Array<PerAttribDataT<T>> *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);


/// Blend float entries from 2 geometry dict detail attributes.
/// This assumes the attributes have the same attribute name on both geometries.
/// The `keys` argument is an array of string containing a key to match at each level.
/// This was implemented to blend a float 'value' entry inside a nested dict.
GU_API bool GUblendDetailDict(
        GU_Detail *gdp,
        const GU_Detail *gdp1,
        const UT_StringHolder &attribute,
        const UT_StringArray &keys,
        const fpreal64 blend);

GU_API bool GUblendDict(
        UT_OptionsHolder &opt0,
        const UT_OptionsHolder &opt1,
        const UT_StringArray &keys,
        const fpreal64 blend);
#endif