CE_VDBGrid.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: CE_VDBGrid.h ( CE Library, C++)
 *
 * COMMENTS: Compute Engine Grid.
 */

#ifndef __CE_VDBGrid__
#define __CE_VDBGrid__

#include "CE_API.h"

#include <UT/UT_Array.h>
#include <UT/UT_NonCopyable.h>
#include <UT/UT_VectorTypes.h>
#include <UT/UT_VDBUtils.h>

#include <SYS/SYS_Types.h>

#include <openvdb/Platform.h>
#include <openvdb/openvdb.h>

#include "CE_BufferHost.h"

class CE_API CE_VDBGrid
{
public:
    CE_VDBGrid() {}
    ~CE_VDBGrid() 
    { 
        releaseBuffer(); 
    };

    UT_NON_COPYABLE(CE_VDBGrid)

    /// Return the underlying OpenCL buffer that can be used in kernel
    /// invocations.
    const cl::Buffer &buffer() const { return myBuffer; }
    exint             bufferSize() const { return myBufferSize; }

    exint             getDeviceMemoryUsage() const
    {
        if (isValid()) return bufferSize();
        return 0;
    }

    /// Deep copy from another grid into this,
    /// if readsrc is false, will only allocate matching size.
    void              copy(const CE_VDBGrid &src, bool readsrc = true);

    UT_VDBType        storageType() const { return myStorageType; }

    /// If the current OpenCL buffer is valid.
    bool              hasBuffer() const { return (myBuffer() != 0);}
    bool              isValid() const { return (myBuffer() != 0);}

    /// Initialize the CE_VDBGrid from the supplied VDB grid.
    void              initFromVDB(const openvdb::GridBase &grid);

    /// Builds a CPU buffer from the VDB provided:
    /// The result is SYSamalloc so must be SYSafreed.
    static void      *allocAlignedBufferFromVDB(const openvdb::GridBase &grid,
                                         exint &size);

    /// Initialize the CE_VDBGrid from the supplied buffers of a nanovdb.
    void              initFromDeviceBuffers(
                            cl::Buffer gridbuffer, exint gridsize, 
                            UT_VDBType storagetype);

    /// Replaces the map transform with the provided one.
    void              updateTransform(const UT_Matrix3D &xform,
                                      const UT_Vector3D &center,
                                      const UT_Vector3D &voxelsize,
                                      double taper);

    /// Initialize from a memory pointer and size.
    /// This will blocking-write to GPU data.
    void              initFromBuffers(const void *data, exint datasize,
                            UT_VDBType storagetype);
    /// Initialize from a given size, allocating only assuming
    /// later code will write to it..
    void              initFromSize(exint datasize,
                            UT_VDBType storagetype);

    /// Utility function to build an tilestart array from a grid.
    static void       buildTileStartsArray(UT_Array<UT_Vector3i> &starts, 
                                           exint &leafcount,
                                           exint &lowercount,
                                           exint &uppercount,
                                           const openvdb::GridBase &grid);

    /// Utility function to build an tilestart array from a nanovdb on cpu.
    static void       buildTileStartsArray(UT_Array<UT_Vector3i> &starts, 
                                           exint &leafcount,
                                           exint &lowercount,
                                           exint &uppercount,
                                           const CE_BufferHostByte &cpugrid);

    /// Create a VDB grid from the CE VDB grid
    openvdb::GridBase::Ptr createVDB() const;

    /// Create a VDB grid from generic memory.
    /// NanoVDB requires 32 byte aligned buffers.
    static openvdb::GridBase::Ptr createVDBFromAlignedBuffer(const void *data, exint datasize);

protected:

    void releaseBuffer();

    cl::Buffer  myBuffer;
    exint       myBufferSize = -1;

    UT_VDBType  myStorageType = UT_VDB_INVALID;
};

#endif