BRAY_SampleFilter.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:        BRAY_SampleFilter.h (RAY Library, C++)
 *
 * COMMENTS:
 */

#ifndef __BRAY_SampleFilter__
#define __BRAY_SampleFilter__

#include "BRAY_API.h"
#include "BRAY_FilterBase.h"
#include <UT/UT_Vector4.h>

class UT_Options;

extern "C" {
    SYS_VISIBILITY_EXPORT extern void newBRAYSampleFilter(void *);
}

/// Sample filters take raw samples as generated by the renderer and can adjust
/// the sample data values prior to sending it to pixel filtering.
class BRAY_API BRAY_SampleFilter
    : public BRAY_FilterBase
{
public:
    class BRAY_API Factory
    {
    public:
        virtual ~Factory();

        /// Create an instance of the BRAY_SampleFilter
        virtual UT_UniquePtr<BRAY_SampleFilter> instance(const UT_Options *o) const = 0;
    };
    using FactoryPtr = UT_UniquePtr<Factory>;

    /// @{
    /// Access to factory
    static void listFactories(UT_StringArray &result);

    static void registerPlugin(const UT_StringHolder &name, FactoryPtr factory);

    static UT_UniquePtr<BRAY_SampleFilter> instancePlugin(
                                const UT_StringRef &style,
                                const UT_Options *options=nullptr);
    static void releasePlugin(UT_UniquePtr<BRAY_SampleFilter> p);
    static void freePluginCache();
    /// @}

    // c-tor
    BRAY_SampleFilter(const UT_Options *o)
        : BRAY_FilterBase(o)
    {
    }

    // d-tor
    ~BRAY_SampleFilter() override;

    /// Sample data for processing
    class BRAY_API SampleData
    {
    public:
        SampleData()
            : mySize(0)
        {}
        SampleData(float **data,        // Sample data for each AOV
                const int *sizes,       // Size of each AOV
                const UT_Vector4 *ndc,
                int nplanes)            // Total number of AOVs
            : myData(data)
            , mySizes(sizes)
            , myNDC(ndc)
            , mySize(nplanes)
        {
        }

        inline void     init(float **data,
                                const int *sizes,
                                const UT_Vector4 *ndc,
                                int nplanes)
        {
            myData = data;
            mySizes = sizes;
            myNDC = ndc;
            mySize = nplanes;
        }
        /// Number of image planes
        inline int               size() const { return mySize; }

        /// @{
        /// Sample data for the given AOV
        inline float            *data(int aov) { return myData[aov]; }
        inline const float      *data(int aov) const { return myData[aov]; }
        /// @}

        /// @{
        /// Sample data for a sample in the given AOV
        inline float            *data(int aov, int sidx)
        {
            return myData[aov] + sidx * mySizes[aov];
        }
        inline const float      *data(int aov, int sidx) const
        {
            return myData[aov] + sidx * mySizes[aov];
        }
        /// @}

        /// Get the pixel location for a given sample
        inline void     pixel(int sidx, int &px, int &py)
        {
            px = int(myNDC[sidx].x());
            py = int(myNDC[sidx].y());
        }
        /// Get the pixel jitter offset a given sample (offset inside pixel)
        /// Note that the jitter may be outside the range (0, 1) depending on
        /// the FIS applied.
        inline void     jitter(int sidx, float &jx, float &jy)
        {
            jx = myNDC[sidx].z();
            jy = myNDC[sidx].w();
        }

        /// The tuple size of the AOV
        inline int               size(int p) const { return mySizes[p]; }
    private:
        float                   **myData;
        const UT_Vector4         *myNDC;
        const int                *mySizes;
        int                       mySize;
    };

    /// @{
    /// Methods to be implemented from base class
    using BRAY_FilterBase::className;
    using BRAY_FilterBase::getAOVs;
    using BRAY_FilterBase::errorMessage;
    /// @}

    /// Process the sample data.  Each AOV plane of the @c data will point to a
    /// contiguous array of sample data which contains at least @c npixels of
    /// data.  The filter should be applied to each pixel in the sample data.
    virtual void         filter(SampleData &data, size_t npixels) const = 0;
};

using BRAY_SampleFilterPtr = UT_UniquePtr<BRAY_SampleFilter>;

#endif