GT_GPUTrace.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:        GT_GPUTrace.h (GU Library, C++)
 *
 * COMMENTS:
 *      This is located in GT so that BRAY (and others) can pass
 *      GT_PolygonMeshes if they don't have GU_Detail's handy.  BRAY might need
 *      to displace/subdivide the geometry.
 */

#ifndef __GT_GPUTrace__
#define __GT_GPUTrace__

#include "GT_API.h"

#include <UT/UT_StringHolder.h>
#include <UT/UT_UniquePtr.h>
#include <UT/UT_StringSet.h>
#include <UT/UT_BitArray.h>
#include <GU/GU_DetailHandle.h>
#include "GT_PrimPolygonMesh.h"

class GU_ConstDetailHandle;

class GT_API GT_GPUTrace
{
public:
    using GT_GPUTracePtr = UT_UniquePtr<GT_GPUTrace>;

    struct GT_API Factory
    {
        Factory();
        virtual ~Factory();
        UT_NON_COPYABLE(Factory)
        virtual GT_GPUTracePtr           newTrace() const = 0;

        // Simple name for the tracer (i.e. optix or embree)
        virtual const UT_StringHolder   &name() const = 0;
        // More descriptive name (i.e. "Optix 8.0.1 driver ..."
        virtual const UT_StringHolder   &label() const = 0;
        // Priority for the tracer.  The faster the execution, the higher the
        // priority.  Embree should probably be 0.
        virtual int                      priority() const = 0;
    };

    // Register a new factory
    static void registerFactory(UT_UniquePtr<Factory> factory);
    // Remove a factory
    static void removeFactory(const UT_StringRef &name);
    // List of all factories
    static void getFactories(UT_Array<const Factory *> &factories);

    enum PrimHandleType
    {
        PHT_GT,
        PHT_GU
    };

    struct PrimitiveInfo
    {
        PrimitiveInfo() = default;
        PrimitiveInfo(const GT_PrimitiveHandle& handle)
            : myGTHandle(handle)
            , myHandleType(PHT_GT)
        { }
        PrimitiveInfo(const GU_ConstDetailHandle& handle)
            : myGUHandle(handle)
            , myHandleType(PHT_GU)
        { }

        GU_ConstDetailHandle    myGUHandle;
        GT_PrimitiveHandle      myGTHandle      = nullptr;
        PrimHandleType          myHandleType    = PHT_GT;

        UT_Array<UT_StringRef>  myFacesSet;

        UT_StringHolder         myName  = UT_StringHolder::theEmptyString;

        // 0=no culling, 1=back, 2=front
        int                     myCullBackFaceMode              = 0;
        int                     myVisibilityCullBackFaceMode    = 0;

        UT_StringHolder         myIdentifierTraceset    = UT_StringHolder::theEmptyString;
        // visiblity tracesets(comma or space separated list)
        UT_StringHolder         myVisibilityTraceset    = UT_StringHolder::theEmptyString;
        UT_Matrix4              myTransform             = UT_Matrix4::getIdentityMatrix();
    };

    enum GT_TraceDirectionMode
    {
        GTDM_Forward,
        GTDM_Backward,
        GTDM_Both
    };

    // occlusion:
    //      nhits = 0
    //      gather(N, 90, nsamples)
    //          nhits += 1
    //      Oc = 1 - nhits / nsamples
    // thickness:
    //      nhits = 0;
    //      gather(-N, 90, nsamples)
    //          dist += ray.tfar
    //      Th = dist / nsamples
    // cavity:
    //      fCv = 0;
    //      cV = 0;
    //      gather(-N, 90, nsamples)
    //          fCv++;
    //      fCv = lerp(1 - (fCv/nsamples), 1, options.myCavityBias);
    // curvature:
    //      cu_convex = 0
    //      cu_cocave = 0
    //      cu_offset = N * options.myCurvatureSBias
    //      gather(P - cu_offset, -N, 90, nsamples, cosine=true)
    //          cu_convex += 1 - ray_dist / options.myCurvatureSBias
    //      gather(P + cu_offset, N, 90, nsamples, cosine=true)
    //          cu_concave += 1 - ray_dist / options.myCurvatureSBias;
    //      cu_convex /= nsamples
    //      cu_concave /= nsamples
    //      auto vop_bias = [](float base, float bias) {
    //          if (base <= 0) return 0;
    //          if (base >= 1) return 1;
    //          return bias / (((1/base) - 2) * (1-bias + 1))
    //      };
    //      fCu = vop_bias(cu_convex, myOptions.myCurvatureBias)
    //          - vop_bias(cu_concave, myOptions.myCurvatureBias);
    //      Cu = fCu * .5 + .5;
    struct BakingOptions
    {
        exint   raysPerPoint() const
        {
            int totalrays = 0;
            if (myOcclusion && myOcclusionSamples)
                totalrays += myOcclusionSamples;
            if (myCavity && myCavitySamples)
                totalrays += myCavitySamples;
            if (myCurvature && myCurvatureSamples)
                totalrays += 2 * myCurvatureSamples;
            if (myThickness && myThicknessSamples)
                totalrays += myThicknessSamples;
            if (myEdge && myEdgeSamples)
                totalrays += myEdgeSamples;
            if (myRoundedNormal && myRoundedNormalSamples)
                totalrays += myRoundedNormalSamples;
            return totalrays;
        }
        bool    needSelfTraceset() const
        {
            return (myEdge && myEdgeSamples > 0) ||
                (myRoundedNormal && myRoundedNormalSamples > 0);
        }

        bool    myOcclusion = true;
        int     myOcclusionSamples = 64;
        float   myOcclusionMaxDist = -1;
        float   myOcclusionRayBias = 0.001;

        bool    myThickness = true;
        int     myThicknessSamples = 16;
        float   myThicknessRayBias = 0.001;

        bool    myCavity = true;
        int     myCavitySamples = 16;
        float   myCavityMaxDist = -1;
        float   myCavityBias = 0.5;
        float   myCavityRayBias = 0.001;

        bool    myCurvature = true;
        int     myCurvatureSamples = 16;
        float   myCurvatureBias = 0.5;
        float   myCurvatureSDist = 0.1;     // ie. ray max distance
        float   myCurvatureScale = 1;
        float   myCurvatureRayBias = 0.002; // myCurvatureSDist * 0.02

        bool    myEdge = true;
        int     myEdgeSamples = 4;
        float   myEdgeRayBias = 0.001;
        float   myEdgeRadius  = 0.01f;
        float   myEdgeCuspAngle = 30.f;
        // 0 concave and convex
        // 1 concave
        // 2 convex
        int     myEdgeMode = 0;

        bool    myRoundedNormal = true;
        int     myRoundedNormalSamples = 4;
        float   myRoundedNormalRayBias = 0.001;
        float   myRoundedNormalRadius  = 0.01f;
        float   myRoundedNormalCuspAngle = 30.f;
        int     myRoundedNormalMode = 0;

        float   myTraceRayBias = 1e-3f;
        GT_TraceDirectionMode myTraceDirection = GTDM_Both;
        int     myPixelSamples = 1;
    };

    /// Allocate a tracer from a particular factory
    static GT_GPUTracePtr       allocTrace(const UT_StringRef &name);

    /// @{
    /// Allocate the best tracer for a given piece of geometry
    static GT_GPUTracePtr       allocTrace(
        const UT_Array<PrimitiveInfo>& prims,
        const UT_StringRef& name,
        const BakingOptions& opts);
    /// @}

    GT_GPUTrace(const Factory &factory)
        : myFactory(factory)
    {
    };
    virtual ~GT_GPUTrace() {};

    UT_NON_COPYABLE(GT_GPUTrace)

    const UT_StringHolder       &name() const { return myFactory.name(); }
    const UT_StringHolder       &label() const { return myFactory.label(); }

    enum DataType
    {
        DT_Int = 0,
        DT_Float,
        DT_Vec2,
        DT_Vec3,
        DT_Vec4,

        DT_NumDataType
    };

    struct AttributeBakeRequest
    {
        // Attribute name.
        UT_StringHolder     myName;
        // Output buffer to write.
        void*               myOutputBuffer;
        // Type of the buffer
        DataType            myType;
    };

    enum BakingCalcTypes
    {
        BCT_Ao,      // Ambient Occlusion
        BCT_Cv,      // Cavity
        BCT_Cu_N,    // Curvature (convex)
        BCT_Cu_P,    // Curvature (concave)
        BCT_Th,      // Thickness
        BCT_Eg,      // Edge
        BCT_Rn,      // Rounded Edge Normal

        BakingCalcType_Num
    };

    // Seeds for various different components
    static constexpr uint   AO_SEED = 0x4c41e0cd;
    static constexpr uint   CV_SEED = 0xf2ee2275;
    static constexpr uint   CU_N_SEED = 0x4b65c61e;
    static constexpr uint   CU_P_SEED = 0x9a4bf788;
    static constexpr uint   TH_SEED = 0x4c910506;
    static constexpr uint   EG_SEED = 0x139fa345;
    static constexpr uint   RN_SEED = 0xe4df7f01;
    static constexpr uint   PIXEL_SEED = 0x73aecd3d;

    /// @{
    /// When init fails
    ///
    bool        init(const UT_Array<PrimitiveInfo>& prims, const BakingOptions& opts);
    /// @}

    /// Note the @c dir vectors must be normalized.
    /// If @c trace_high_res is true, High res mesh info are traced using
    /// rays with given @c org and @c dir, typically on the Low res mesh,
    /// and, if @c opts.myPixelSamples also is 1, the input @c org and @c dir are
    /// so modified by the results with @c dir being the surface normal.
    /// @c tanu and @c tanv are tangent vectors on Low res mesh that correspond
    /// to each pixel. They are used to jitter the @c org.
    /// Both vectors can be passed null if @c opts.myPixelSamples is 1.
    virtual void        computeBaking(exint nrays,
                                    UT_Vector3 *org,
                                    UT_Vector3 *dir,
                                    const float *tfar,
                                    const BakingOptions &opts,
                                    bool  trace_high_res,
                                    UT_Array<AttributeBakeRequest>& requests,
                                    const UT_StringHolder *bakemesh_tracesets,
                                    const UT_Vector3 *tanu = nullptr,
                                    const UT_Vector3 *tanv = nullptr,
                                    float *ao = nullptr,
                                    float *cavity = nullptr,
                                    float *curvature = nullptr,
                                    float *thickness = nullptr,
                                    float *edge = nullptr,
                                    UT_Vector3 *rn = nullptr) const = 0;

    static inline float vop_bias(float base, float bias)
    {
        if (base <= 0)
            return 0;
        if (base >= 1)
            return 1;
        return SYSsafediv(bias, (1 + (SYSsaferecip(base) - 2)*(1-bias)));
    }

    struct AttribInfo
    {
        void*               myData;
        GT_DataArrayHandle  myBuffer;
        exint               myEntries;
        GT_Owner            myOwner;
        DataType            myType;

        bool            isValid() const
            { return myData && myEntries > 0; }
    };

    struct MeshData
    {
        UT_StringHolder             myName          = UT_StringHolder::theEmptyString;
        GT_PrimitiveHandle          myPrim          = nullptr;
        GT_DataArrayHandle          myVertexStorage = nullptr;
        GT_DataArrayHandle          myPStorage      = nullptr;
        GT_DataArrayHandle          myNStorage      = nullptr;
        const UT_Vector3i*          myIndices       = nullptr;
        const UT_Vector3*           myNormals       = nullptr;
        GT_Owner                    myNormalOwner   = GT_OWNER_INVALID;
        const GT_PrimPolygonMesh    *myMesh         = nullptr;
        bool                        myLeftHanded    = false;

        // 0=no culling, 1=back, 2=front
        int                         myCullBackFaceMode  = 0;
        int                         myVisibilityCullBackFaceMode  = 0;

        UT_Matrix4                  myTransform = UT_Matrix4::getIdentityMatrix();;

        // tracesets data
        UT_StringHolder             myIdentifierTraceset;
        UT_StringHolder             myVisibilityTraceset;
        // set of mesh indices corresponding to
        // tracesets defined by VisibilityTraceset
        UT_Set<int>                 myVisiblityMeshes;
        // uniq bit mask for tracesets defined by VisibilityTraceset
        UT_BitArray                 myIdentifierBitArray;
        UT_BitArray                 myVisibilityBitArray;
        UT_BitArray                 mySelfBitArray;

        UT_StringMap<AttribInfo>    myAttributes;

        void clear()
        {
            myPrim.reset();
            myPStorage.reset();
            myVertexStorage.reset();
            myNStorage.reset();
            myAttributes.clear();
            myNormalOwner = GT_OWNER_INVALID;
            myNormals = nullptr;
            myIndices = nullptr;
            myMesh = nullptr;
        }
    };

protected:

    virtual bool        doInit(const UT_Array<PrimitiveInfo>& prims,
        const BakingOptions& opts) = 0;

    struct TraceSet
    {
        UT_StringHolder name = UT_StringHolder::theEmptyString;
        // traceset index. idx0 is reserved for all objects
        int         index = 0;
        // bitmask with only this trace bit set
        UT_BitArray bitmask;
    };

    // traceset
    UT_StringMap<UT_Set<int>>     myTracesetNameToMeshes;
    // a map from set of mesh indices to unique traceset
    // one entry is added for all objects
    UT_Map<UT_Set<int>, TraceSet> myMeshSetToTraceSet;

    const TraceSet*     bakeMeshTraceSet(const UT_StringHolder& name) const;
    const TraceSet&     getTheAllTraceset() const;
    void                buildTracesets(UT_Array<MeshData*>& meshes, bool selfset);

    bool                leftHanddedMesh(const GT_PrimPolygonMesh *pmesh) const;
    const fpreal32*     normals(const GT_PrimPolygonMesh *pmesh,
                                GT_DataArrayHandle &handle,
                                exint& count,
                                GT_Owner& owner) const;

    void                getAttribute(
                                const UT_StringHolder& name,
                                const GT_PrimPolygonMesh *pmesh,
                                AttribInfo& attrinfo) const;

private:
    void                dumpTracesets(UT_Array<MeshData*>& meshes) const;

    const Factory       &myFactory;
};

using GT_GPUTracePtr = GT_GPUTrace::GT_GPUTracePtr;

extern "C" {
    // DSO function called to register tracers
    SYS_VISIBILITY_EXPORT extern void   newGPUTrace();
};

#endif