CE_OSDPatchEval.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_OSDPatchEval.h ( CE Library, C++)
 *
 * COMMENTS: OpenSubdiv patch-based evaluation on the limit surface.
 */

#ifndef __CE_OSDPatchEval__
#define __CE_OSDPatchEval__

#include "CE_API.h"
#include "CE_Array.h"

#include <SYS/SYS_Types.h>
#include <UT/UT_Array.h>
#include <UT/UT_Span.h>

class CE_OSDRefinement;
class CE_OSDEvaluator;

/// Opaque device-side storage for OSD patch coordinates.
/// The underlying element type is internal to CE_OSDPatchEval.C.
class CE_API CE_OSDPatchCoords
{
public:
    CE_OSDPatchCoords() = default;
    CE_OSDPatchCoords(CE_OSDPatchCoords &&) = default;
    CE_OSDPatchCoords &operator=(CE_OSDPatchCoords &&o) noexcept
    {
        swap(myBuffer, o.myBuffer);
        UTswap(myElemSize, o.myElemSize);
        return *this;
    }

    exint size() const
    {
        return myElemSize ? myBuffer.size() / myElemSize : 0;
    }

    const cl::Buffer &buffer() const { return myBuffer.buffer(); }
    void clear()
    {
        myBuffer.reset(cl::Buffer());
        myElemSize = 0;
    }

    template <typename T>
    void initFromArray(const UT_Array<T> &src)
    {
        myElemSize = sizeof(T);
        myBuffer.initFromData(
            reinterpret_cast<const uint8 *>(src.data()),
            src.size() * sizeof(T));
    }

private:
    CE_BufferDevice<uint8> myBuffer;
    exint myElemSize = 0;
};

namespace CE_OSDPatchEval
{
    /// Build patch coordinates from ptex face/u/v.
    /// Must be called successfully before evaluate().
    /// faces/u/v must have identical lengths.
    /// Returns false if any entry is invalid (negative face or no patch hit)
    /// and clears patch_coords.
    /// For empty input, returns true and clears patch_coords.
    CE_API bool buildPatchCoords(
        const CE_OSDRefinement &topo,
        UT_Span<const int> faces,
        UT_Span<const float> u,
        UT_Span<const float> v,
        CE_OSDPatchCoords &patch_coords);

    /// Optional pre-refinement step for patch evaluation inputs.
    /// Call before evaluate() when topo has stencil refinement points
    /// (topo.numRefinedVerts() > 0 && topo.hasStencilCL()).
    /// coarse is caller-owned and must contain at least
    /// tuple_size * topo.numCoarseVerts() floats.
    /// When refinement is needed, refined_data is caller-owned and must be
    /// pre-allocated to tuple_size * topo.numRefinedVerts() floats.
    /// When refinement is not needed, returns true and leaves refined_data
    /// unchanged.
    /// On failure, returns false.
    CE_API bool refine(const CE_OSDRefinement &topo,
                       const CE_OSDEvaluator &eval,
                       const cl::Buffer &coarse,
                       CE_FloatArray &refined_data);

    /// Evaluate coarse data on limit patches.
    /// Call buildPatchCoords() before evaluate(). If topo has stencil
    /// refinement points (topo.numRefinedVerts() > 0 && topo.hasStencilCL()),
    /// refine() must be called successfully before evaluate().
    /// If patch_coords is empty, evaluate() is a no-op and returns true.
    /// coarse/out/du/dv are caller-owned.
    /// out must be pre-allocated to at least
    /// tuple_size * patch_coords.size() floats.
    /// du/dv are optional; if provided, they must also be pre-allocated to
    /// at least tuple_size * patch_coords.size() floats.
    /// refined_data is ignored when no refinement is needed; otherwise it
    /// must be non-null and sized to tuple_size * topo.numRefinedVerts().
    /// On failure, returns false.
    CE_API bool evaluate(const CE_OSDRefinement &topo,
                         const CE_OSDEvaluator &eval,
                         const cl::Buffer &coarse,
                         const CE_OSDPatchCoords &patch_coords,
                         const CE_FloatArray *refined_data,
                         cl::Buffer &out,
                         cl::Buffer *du,
                         cl::Buffer *dv);
}

#endif