GU_PointDeform.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_Cosserat.h ( CE Library, C++)
 *
 * COMMENTS: Functions to perform stable cosserat rods simulation.
 */

#pragma once

#include "GU_API.h"
#include <CE/CE_Array.h>
#include <UT/UT_Array.h>
#include <UT/UT_Quaternion.h>
#include <UT/UT_Span.h>
#include <UT/UT_Matrix3.h>
#include <UT/UT_Vector3.h>
#include <UT/UT_ErrorLog.h>
#include <variant>

class CE_Context;

namespace GU_PointDeform
{

class CachedItems
{
public:
    void loadKernels(
            CE_Context &context,
            int n,
            int ndeformerpts,
            bool recompile);

    template <typename T>
    class Buffer
    {
    public:
        void initIfInternal(exint size)
        {
            if (std::holds_alternative<CE_Array<T>>(myBuffer))
                return std::get<CE_Array<T>>(myBuffer).init(size);
        };

        cl::Buffer buffer()
        {
            if (std::holds_alternative<CE_Array<T>>(myBuffer))
                return std::get<CE_Array<T>>(myBuffer).buffer();
            else
                return std::get<cl::Buffer>(myBuffer);
        }

        void setExternal(cl::Buffer buffer) { myBuffer = buffer; }

        void setInternal()
        {
            if (!std::holds_alternative<CE_Array<T>>(myBuffer))
                myBuffer = CE_Array<T>();
        }
        bool isExternal()
        {
            return std::holds_alternative<cl::Buffer>(myBuffer);
        }

    private:
        std::variant<CE_Array<T>, cl::Buffer> myBuffer;
    };

    class Buffers
    {
    public:
        bool init(int npts, int ndeformerpts);

        Buffer<float> myDeformerRestPos;
        Buffer<float> myDeformerAnimPos;
        Buffer<float> myDeformerRestOrient;
        Buffer<float> myDeformerAnimOrient;
        Buffer<float> myDeformerXform;
        Buffer<float> myNeighboursIndex;
        Buffer<float> myNeighbours;

        Buffer<float> myPos;
        Buffer<float> myOrient;
        Buffer<float> myXform;
        Buffer<float> myTranslate;
        Buffer<float> myPtsIndex;
        Buffer<float> myPts;
        Buffer<float> myWeightsIndex;
        Buffer<float> myWeights;

    } myBuffers;

    struct Kernels
    {
        cl::KernelFunctor mySeqXform;
        cl::KernelFunctor myOrientXform;
        cl::KernelFunctor myComputeTransform;
        cl::KernelFunctor myTranslate;
        cl::KernelFunctor myRotateQuat;
    } myKernels;

public:
    Buffers &getBuffers() { return myBuffers; }
    Kernels &getKernels() { return myKernels; }
};

} // namespace GU_PointDeform

GU_API bool
GUpointDeformInit(
        GU_PointDeform::CachedItems &cached_items,
        CE_Context &context,
        int npts,
        int ndeformerpts,
        bool recompile);

GU_API bool
GUpointDeformSeqXform(
        GU_PointDeform::CachedItems &cached_items,
        CE_Context &context,
        int ndeformerpts,
        bool recompile);

GU_API bool
GUpointDeformOrientXform(
        GU_PointDeform::CachedItems &cached_items,
        CE_Context &context,
        int ndeformerpts,
        bool recompile);

GU_API void
GUpointDeformComputeTransform(
        GU_PointDeform::CachedItems &cached_items,
        CE_Context &context,
        int npts,
        bool recompile);

GU_API void
GUpointDeformTranslate(
        const cl::Buffer &outpos,
        const cl::Buffer &inpos,
        GU_PointDeform::CachedItems &cached_items,
        CE_Context &context,
        int npts,
        bool recompile,
        const cl::Buffer *mask = nullptr);

GU_API void
GUpointDeformRotateQuat(
        const cl::Buffer &outorient,
        const cl::Buffer &inorient,
        GU_PointDeform::CachedItems &cached_items,
        CE_Context &context,
        int npts,
        bool recompile);

GU_API void
GUpointDeformComputeCapture(
        UT_IntArray &captStarts,
        UT_IntArray &captPts,
        UT_FloatArray &captWeights,
        UT_Span<const UT_Vector3F> querypos,
        UT_Span<const UT_Vector3F> deformerpos,
        float radius,
        int maxpts,
        int minpts);