GU_SurfaceDeform.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_SurfaceDeform.h ( GU Library, C++)
 *
 * COMMENTS: Surface deform capture, frame computation, and GPU deformation.
 */

#pragma once

#include "GU_API.h"
#include "GU_Detail.h"
#include "GU_RayIntersect.h"

#include <CE/CE_Array.h>
#include <GA/GA_Handle.h>
#include <GA/GA_Types.h>
#include <GEO/GEO_Interpolate.h>
#include <UT/UT_Array.h>
#include <UT/UT_ErrorLog.h>
#include <UT/UT_Matrix3.h>
#include <UT/UT_Matrix4.h>
#include <UT/UT_Tracing.h>
#include <UT/UT_UniquePtr.h>
#include <UT/UT_Vector3.h>

#include <numeric>
#include <type_traits>

class CE_Context;

namespace GU_SurfaceDeform
{

template <typename T, typename Container>
struct ArrayAccessorBracketPolicy
{
    Container& myContainer;

    ArrayAccessorBracketPolicy(Container& container)
        : myContainer(container) {}

    inline T get(size_t i) const noexcept
    {
        return myContainer[i];
    }

    inline void set(size_t i, const T &value) noexcept
    {
        myContainer[i] = value;
    }

    inline size_t size() const noexcept
    {
        return myContainer.size();
    }
};

template <typename T, typename Container, typename Policy>
struct ArrayAccessor
{
    using value_type = T;
    Policy policy;

    ArrayAccessor(Container& container)
        : policy(container) {}

    ArrayAccessor(Container& container, Policy &policy)
        : policy(policy) {}

    inline T operator[](size_t i) const noexcept {
        return policy.get(i);
    }

    inline void set(size_t i, const T &value) noexcept {
        policy.set(i, value);
    }

    inline size_t size() const noexcept {
        return policy.size();
    }
};

/// As surfaceInterpOffsets(), but the caller decides which intersector each
/// position is projected against: resolve(i, pos, mininfo) fills in mininfo,
/// leaving it untouched to drop position i from the capture.  Used to restrict
/// a capture to the surface pieces matching the position's id.
///
/// ptcapture picks its own point form: a GA_OffsetArray takes the surface
/// offsets, a UT_IntArray the point indices the GPU kernels index by.
template<typename PA, typename RESOLVER, typename PTARRAY>
void
surfaceInterpOffsetsFromResolver(
        UT_IntArray &primptstarts,
        PTARRAY &ptcapture,
        UT_FloatArray &ptweights,
        const PA &positions,
        const GU_Detail &surfacegdp,
        const RESOLVER &resolve)
{
    using PtType = typename PTARRAY::value_type;
    static_assert(
            std::is_same_v<PtType, GA_Offset> || std::is_same_v<PtType, int>,
            "surface capture points come out as GA_Offset or point index");

    utZoneScoped;
    GA_OffsetArray primoffsets;
    UT_Vector3Array primuvs;
    UT_IntArray primptcounts;

    primoffsets.setSizeNoInit(positions.size());
    primuvs.setSizeNoInit(positions.size());

    primptcounts.setSizeNoInit(positions.size());
    primptstarts.setSizeNoInit(positions.size()+1);

    {
    utZoneScopedN("counts");
    UTparallelFor(
        UT_BlockedRange<exint>(0, positions.size()),
        [&](const UT_BlockedRange<exint> &r)
    {
        utZoneScopedN("task");
        for (exint i = r.begin(), end = r.end(); i < end; ++i)
        {
            UT_Vector3 pos = positions[i];

            GU_MinInfo mininfo{};
            resolve(i, pos, mininfo);

            GA_Offset primoff = mininfo.prim.offset();

            if (primoff != GA_INVALID_OFFSET)
            {
                primoffsets[i] = primoff;
                primuvs[i] = UT_Vector3(mininfo.u1, mininfo.v1, 0.0f);
                primptcounts[i] = surfacegdp.getPrimitiveVertexCount(primoff);
            }
            else
            {
                primoffsets[i] = GA_INVALID_OFFSET;
                primuvs[i] = UT_Vector3(0.0f);
                primptcounts[i] = 0;
            }
        }
    });
    }

    {
    utZoneScopedN("scan");
    primptstarts[0] = 0;
    std::inclusive_scan(
            primptcounts.begin(), primptcounts.end(),
            primptstarts.begin() + 1);
    }

    GA_Size offsetcount = primptstarts[primptstarts.size()-1];
    ptcapture.setSizeNoInit(offsetcount);
    ptweights.setSizeNoInit(offsetcount);

    {
    utZoneScopedN("offsets");
    UTparallelFor(
        UT_BlockedRange<exint>(0, positions.size()),
        [&](const UT_BlockedRange<exint> &r)
    {
        utZoneScopedN("task");
        for (exint i = r.begin(), end = r.end(); i < end; ++i)
        {
            GA_Offset primoff = primoffsets[i];
            UT_Vector3 primuv = primuvs[i];

            if (primoff == GA_INVALID_OFFSET)
                continue;

            UT_Array<GA_Offset> offsets;
            UT_Array<float> weights;
            GEOgetInterpolationWeights(
                    &surfacegdp, primoff, offsets, weights, primuv, true);

            for (int j=0; j<offsets.size(); ++j)
            {
                if constexpr (std::is_same_v<PtType, GA_Offset>)
                    ptcapture[primptstarts[i] + j] = offsets[j];
                else
                    ptcapture[primptstarts[i] + j] =
                            surfacegdp.pointIndex(offsets[j]);
                ptweights[primptstarts[i] + j] = weights[j];
            }
        }
    });
    }
}

template<typename PA, typename PTARRAY>
void
surfaceInterpOffsets(
        UT_IntArray &primptstarts,
        PTARRAY &ptcapture,
        UT_FloatArray &ptweights,
        const PA &positions,
        const GU_Detail &surfacegdp,
        const GU_RayIntersect &rayintersect)
{
    surfaceInterpOffsetsFromResolver(
            primptstarts, ptcapture, ptweights, positions, surfacegdp,
            [&rayintersect](exint, const UT_Vector3 &pos, GU_MinInfo &mininfo)
            {
                rayintersect.minimumPoint(pos, mininfo);
            });
}

GU_API void
computeFrames(
        const GU_Detail &gdp,
        const GA_ROHandleV3 &poshandle,
        GA_AttributeUPtr &nmlowner,
        GA_AttributeUPtr &tanowner);

template <
        typename OUTPOS,
        typename INPOS,
        typename DEFRESTPOS,
        typename DEFANIMPOS>
void
deform(
        OUTPOS &newposdata,
        const INPOS &points,
        const DEFRESTPOS &constrestpos,
        const DEFANIMPOS &constanimpos,
        const GU_Detail &defgdp,
        const GA_ROHandleV3 restnmlattrib,
        const GA_ROHandleV3 resttanattrib,
        const GA_ROHandleV3 animnmlattrib,
        const GA_ROHandleV3 animtanattrib,
        const UT_IntArray &primptstarts,
        const GA_OffsetArray &ptoffsets,
        const UT_FloatArray &ptweights)
{
    utZoneScoped;
    using value_type = typename OUTPOS::value_type;
    UTparallelFor(
        UT_BlockedRange<exint>(0, points.size()),
        [&](const UT_BlockedRange<exint> &r)
        {
            for (exint i = r.begin(), end = r.end(); i < end; ++i)
            {
                GA_Size ptstart = primptstarts[i];
                GA_Size ptend = primptstarts[i + 1];
                if (ptstart != ptend)
                {
                    UT_Vector3 restpos(0.0f);
                    UT_Vector3 animpos(0.0f);

                    UT_Vector3 restnml(0.0f);
                    UT_Vector3 animnml(0.0f);

                    UT_Vector3 resttan(0.0f);
                    UT_Vector3 animtan(0.0f);

                    for (int j = ptstart; j < ptend; ++j)
                    {
                        GA_Offset ptoff = ptoffsets[j];
                        GA_Size index = defgdp.pointIndex(ptoff);

                        float w = ptweights[j];
                        restpos += w * constrestpos[index];
                        animpos += w * constanimpos[index];

                        restnml += w * restnmlattrib.get(ptoff);
                        animnml += w * animnmlattrib.get(ptoff);

                        resttan += w * resttanattrib.get(ptoff);
                        animtan += w * animtanattrib.get(ptoff);
                    }

                    restnml.normalize();
                    animnml.normalize();

                    resttan.normalize();
                    animtan.normalize();

                    UT_Matrix3 deformrot;
                    deformrot.lookat(UT_Vector3(0.0f), animnml, animtan);
                    UT_Matrix4 deformspace(deformrot);
                    deformspace.translate(animpos);

                    UT_Matrix3 restrot;
                    restrot.lookat(UT_Vector3(0.0f), restnml, resttan);
                    UT_Matrix4 restspace(restrot);
                    restspace.translate(restpos);

                    restspace.invert();

                    if constexpr(std::is_same_v<value_type, UT_Matrix4>)
                    {
                        newposdata.set(i, restspace * deformspace);
                    }
                    else
                    {
                        UT_Vector3 pos(points[i].data());
                        pos *= restspace * deformspace;

                        newposdata.set(i, pos);
                    }
                }
                else
                {
                    // fall back to undeformed xform/position
                    if constexpr(std::is_same_v<value_type, UT_Matrix4>)
                    {
                        newposdata.set(i, UT_Matrix4(1.0f));
                    }
                    else
                    {
                        newposdata.set(i, points[i].data());
                    }
                }
            }
        });
}

class GU_API Capture
{
public:
    void init(const GU_Detail &surfaceGdp);

    // Project positions onto rest surface mesh.
    // Outputs per-position: contributing mesh point indices + barycentric
    // weights.
    // PA must support operator[](int) -> UT_Vector3 and size() -> int.
    template<typename PA>
    void project(
        UT_IntArray &ptStarts,
        UT_IntArray &ptIndices,
        UT_FloatArray &ptWeights,
        const PA &positions)
    {
        surfaceInterpOffsets(
            ptStarts,
            ptIndices,
            ptWeights,
            positions,
            *myRestSurface,
            *myRayIntersect);
    }

    const GU_Detail &restSurface() const { return *myRestSurface; }

private:
    UT_UniquePtr<GU_Detail> myRestSurface;
    UT_UniquePtr<GU_RayIntersect> myRayIntersect;
};

/// CPU-side capture for subdivision surface deformation.
/// Copies the rest surface and projects positions onto it via ray
/// intersection.  The GT topology building and ptex conversion must
/// be performed externally (GT symbols can't link from GU).
class GU_API SubdCapture
{
public:
    /// Copy rest surface and build ray intersect.
    void init(const GU_Detail &restSurfaceGdp);

    /// Project positions onto the rest surface coarse mesh.
    /// Outputs per-position: coarse face index (prim index into rest gdp),
    /// barycentric u/v.  Face index is -1 if the point was not captured.
    /// PA must support operator[](int) -> UT_Vector3 and size() -> int.
    /// Returns false on hard errors (invalid state).
    template<typename PA>
    bool project(
        UT_IntArray &coarseFace,
        UT_FloatArray &coarseU,
        UT_FloatArray &coarseV,
        const PA &positions)
    {
        utZoneScoped;
        if (!myRayIntersect || !myRestSurface)
            return false;

        const exint numpts = positions.size();
        coarseFace.setSizeNoInit(numpts);
        coarseU.setSizeNoInit(numpts);
        coarseV.setSizeNoInit(numpts);

        {
            utZoneScopedN("subd_project_ray");
            UTparallelFor(
                UT_BlockedRange<exint>(0, numpts),
                [&](const UT_BlockedRange<exint> &r)
            {
                for (exint i = r.begin(), end = r.end(); i < end; ++i)
                {
                    GU_MinInfo mininfo{};
                    myRayIntersect->minimumPoint(positions[i], mininfo);
                    GA_Offset primoff = mininfo.prim.offset();
                    if (primoff != GA_INVALID_OFFSET)
                    {
                        coarseFace[i] =
                            (int)myRestSurface->primitiveIndex(primoff);
                        coarseU[i] = mininfo.u1;
                        coarseV[i] = mininfo.v1;
                    }
                    else
                    {
                        coarseFace[i] = -1;
                        coarseU[i] = 0.5f;
                        coarseV[i] = 0.5f;
                    }
                }
            });
        }

        return true;
    }

    bool isValid() const { return myRestSurface != nullptr; }
    const GU_Detail &restSurface() const { return *myRestSurface; }

private:
    UT_UniquePtr<GU_Detail> myRestSurface;
    UT_UniquePtr<GU_RayIntersect> myRayIntersect;
};

GU_API void
computeWeightedXform(
    CE_Context &context,
    bool recompile,
    int nprims,
    CE_Array<float> &surfacexform,
    const cl::Buffer &surfacePtStarts,
    const cl::Buffer &surfacePtIndices,
    const cl::Buffer &surfacePtWeights,
    const cl::Buffer &restPos,
    const cl::Buffer &restNml,
    const cl::Buffer &restTan,
    const cl::Buffer &animPos,
    const cl::Buffer &animNml,
    const cl::Buffer &animTan,
    const cl::Buffer *grp = nullptr);

GU_API void
computeXform(
    CE_Context &context,
    bool recompile,
    int nprims,
    CE_Array<float> &surfacexform,
    const cl::Buffer &restPos,
    const cl::Buffer &restNml,
    const cl::Buffer &restTan,
    const cl::Buffer &animPos,
    const cl::Buffer &animNml,
    const cl::Buffer &animTan,
    const cl::Buffer *grp = nullptr);

GU_API void
indexedXform(
    CE_Context &context,
    bool recompile,
    int npts,
    const cl::Buffer &outPos,
    const cl::Buffer &inPos,
    const cl::Buffer &surfacexform,
    const cl::Buffer &pointPrimsIndex,
    const cl::Buffer &pointPrims,
    const cl::Buffer *grp = nullptr,
    const cl::Buffer *mask = nullptr);

GU_API void
xform(
    CE_Context &context,
    bool recompile,
    int npts,
    const cl::Buffer &outPos,
    const cl::Buffer &inPos,
    const cl::Buffer &surfacexform,
    const cl::Buffer *grp = nullptr);

}