GU_OSDEval.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_OSDEval.h ( GU Library, C++)
 *
 * COMMENTS: GPU subdivision surface evaluator.
 *           Wraps CE_OSD* classes to evaluate limit surface attributes.
 */

#pragma once

#include "GU_API.h"
#include "GU_OSDTopology.h"

#include <CE/CE_Array.h>
#include <CE/CE_Context.h>
#include <CE/CE_OSDEvaluator.h>
#include <CE/CE_OSDPatchEval.h>
#include <CE/CE_OSDRefinement.h>
#include <UT/UT_Array.h>
#include <UT/UT_Span.h>
#include <UT/UT_UniquePtr.h>

/// GPU-side evaluator for subdivision surface limit attributes.
/// Owns topology, evaluator, and cached patch/refined buffers.
class GU_API GU_OSDEval
{
public:
    ~GU_OSDEval();

    /// Initialize evaluator kernels for a tuple size.
    /// Must be called before evaluate().
    bool initEvaluator(
        CE_Context &context,
        int tuple_size);

    /// Build CL topology from an OpenSubdiv TopologyRefiner.
    /// Caller must call initEvaluator() first.
    bool setTopology(
        const GU_OSDTopology &topology,
        CE_Context &context);

    /// Upload patch coordinates.  Call when capture changes.
    bool setPatchCoords(
        UT_Span<const int> patchFace,
        UT_Span<const float> patchU,
        UT_Span<const float> patchV);

    /// Evaluate a coarse attribute on the limit surface.
    /// Call order requirement: initEvaluator() -> setTopology() ->
    /// setPatchCoords()
    /// before evaluate().
    /// setPatchCoords() must be called again after every successful
    /// setTopology() and whenever the patch face/u/v inputs change.
    /// If setPatchCoords() captured zero points, evaluate() returns false.
    /// coarseData is already on GPU (e.g. from GA_CEAttribute::bufferR()).
    /// outDu/outDv are optional derivative outputs and are caller-owned.
    bool evaluate(
        const cl::Buffer &coarseData,
        cl::Buffer &outResult,
        cl::Buffer *outDu = nullptr,
        cl::Buffer *outDv = nullptr);

    const CE_OSDRefinement *refinement() const { return myRefinement.get(); }

    /// Returns true when evaluator + topology are initialized.
    /// Patch coordinates are tracked separately via setPatchCoords().
    bool isValid() const
    {
        return myRefinement && myEvaluator;
    }

    // In-kernel evaluation support

    /// Stencil-eval coarse -> refined control points.
    /// Lazily creates/caches evaluator for the given tuple_size.
    /// refinedOut must be pre-allocated to numRefinedVerts * tuple_size.
    bool refineAttribute(
        CE_Context &context,
        const cl::Buffer &coarseData,
        int tuple_size,
        CE_FloatArray &refinedOut);

    int numFaces() const { return myNumFaces; }
    int numPatches() const;
    int numPatchArrays() const;

    /// int2[numFaces] table: (firstPatchIdx, patchCount) per coarse face.
    /// Built on first call, cached until next setTopology().
    const cl::Buffer *faceToPatchBuffer();
    /// int[numPatchFaces] table mapping patch face -> coarse face id.
    const cl::Buffer *patchToFaceBuffer();

    /// Delegates to CE_OSDRefinement:
    cl::Buffer patchArrayBuffer() const;
    cl::Buffer patchIndexBuffer() const;
    cl::Buffer patchParamBuffer() const;


private:
    UT_UniquePtr<CE_OSDRefinement> myRefinement;
    UT_UniquePtr<CE_OSDEvaluator> myEvaluator;
    CE_OSDPatchCoords myPatchCoords;
    CE_FloatArray myRefinedData;
    bool myHasPatchCoords = false;

    // In-kernel evaluation state
    UT_Array<CE_OSDEvaluator> myEvaluators;  // Cached by tuple size
    UT_Array<int> myFaceFirstPatch;
    CE_Array<int> myFaceToPatch;
    CE_Array<int> myPatchToFace;
    int myNumFaces = 0;
    int myNumPatches = 0;

    CE_OSDEvaluator *getOrCreateEvaluator(
        CE_Context &context, int tuple_size);
};