RixInterfaces.h

Go to the documentation of this file.

/*
# ------------------------------------------------------------------------------
#
# Copyright (c) 1986-2019 Pixar. All rights reserved.
#
# The information in this file (the "Software") is provided for the exclusive
# use of the software licensees of Pixar ("Licensees").  Licensees have the
# right to incorporate the Software into other products for use by other
# authorized software licensees of Pixar, without fee. Except as expressly
# permitted herein, the Software may not be disclosed to third parties, copied
# or duplicated in any form, in whole or in part, without the prior written
# permission of Pixar.
#
# The copyright notices in the Software and this entire statement, including the
# above license grant, this restriction and the following disclaimer, must be
# included in all copies of the Software, in whole or in part, and all permitted
# derivative works of the Software, unless such copies or derivative works are
# solely in the form of machine-executable object code generated by a source
# language processor.
#
# PIXAR DISCLAIMS ALL WARRANTIES WITH REGARD TO THIS SOFTWARE, INCLUDING ALL
# IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL PIXAR BE
# LIABLE FOR ANY SPECIAL, INDIRECT OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
# WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN ACTION
# OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF OR IN
# CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.  IN NO CASE WILL
# PIXAR'S TOTAL LIABILITY FOR ALL DAMAGES ARISING OUT OF OR IN CONNECTION WITH
# THE USE OR PERFORMANCE OF THIS SOFTWARE EXCEED $50.
#
# Pixar
# 1200 Park Ave
# Emeryville CA 94608
#
# ------------------------------------------------------------------------------
*/


#ifndef RixInterfaces_h
#define RixInterfaces_h

#include <cstddef>                      // for NULL, size_t
#include <utility>                      // for std::move
#include "RiTypesHelper.h"              // for RtFloat3, RtUString, etc

class RixLPEState;
class RixShadingContext;
class RiPredefinedStrings;

enum RixInterfaceId
{
    // clang-format off
    k_RixThreadUtils = 0,  
    k_RixMessages,         
    k_RixGlobalData = 3,   
    k_RixThreadData,       
    k_RixLocalData,        
    k_RixSessionData = 8,  
    k_RixXcpt,             
    k_RixRIB,              
    k_RixDeepTexture,      
    k_RixRIBParser = 13,   
    k_RixStats,            
    k_RixTimer,            
    k_RixRenderState = 18, 
    k_RixRiCtl = 20,       
    k_RixSymbolResolver,   
    k_RixGeoDebugger = 23, 
    k_RixTexture,          
    k_RixShadeFunctions,   
    k_RixTransform,        
    k_RixResourceResolver, 
    k_RixLPEInfo,          
    k_RixCustomLPE,        
    k_RixTexture3d,        
    k_RixDspy,             
    k_RixShaderInfo,       
    k_RixHashUtils,        
    k_RixSGManager,        
    k_RixEventCallbacks    
    // clang-format on
};

class RixInterface
{
public:
    // type of the results returned by
    // - RixRenderState::GetAttribute
    // - RixRenderState::GetOption
    // - RixTexture::GetProperty
    enum Type
    {
        k_Float,
        k_Integer,
        k_StringV,
        k_Color,
        k_Normal,
        k_Vector,
        k_Point,
        k_HPoint,
        k_MPoint,
        k_Matrix
    };
    virtual int GetVersion() const { return m_version; }

protected:
    int m_version;

    RixInterface(int version) : m_version(version) {}

    virtual ~RixInterface() {}
};

class RixContext
{
public:
    virtual RixInterface* GetRixInterface(RixInterfaceId id) const = 0;

    virtual ~RixContext() {}
};

class RixXcpt : public RixInterface
{
public:
    class XcptHandler
    {
    public:
        virtual void HandleXcpt(int code, int severity, const char* msg) = 0;
        virtual void HandleExitRequest(int code) = 0;

    protected:
        virtual ~XcptHandler() {}
    };

    virtual void Register(XcptHandler*) = 0;

    virtual void Unregister(XcptHandler*) = 0;

    virtual void SetBuiltinHandler(RtUString name) = 0;

protected:
    RixXcpt() : RixInterface(1) {}
};


class RixHashUtils : public RixInterface
{
public:
    virtual uint32_t XXHash32(void const* input, size_t size, unsigned seed)=0;

    virtual uint64_t XXHash64(void const* input, size_t size, unsigned seed)=0;

protected:
    RixHashUtils() : RixInterface(1) {}
};

class RixMessages : public RixInterface
{
public:

    virtual void Error(const char* format, ...) = 0;

    virtual void ErrorAlways(const char* format, ...) = 0;

    virtual void Warning(const char* format, ...) = 0;

    virtual void WarningAlways(const char* format, ...) = 0;

    virtual void Info(const char* format, ...) = 0;

    virtual void InfoAlways(const char* format, ...) = 0;

protected:
    RixMessages() : RixInterface(1) {}
};

class RixTexture : public RixInterface
{
public:
    enum ErrType
    {
        Ok = 0,
        FileNotFound,
        PartNotFound,
        InvalidFaceIndex,
        TextureAccessErr,
        InvalidDerivatives,
        InvalidFilter,
        InvalidFile
    };

    class TxProperties
    {
    public:
        enum TextureType
        {
            texture = 0,
            ptexture,
            latlong,
            cubeface,
            shadow,
            deepshadow,
            textureatlas,
        };

        TxProperties()
            : version(2),
              fileHandle(NULL),
              nchannels(0),
              channelTypes(NULL),
              nparts(0),
              width(0),
              height(0),
              pixelAspectRatio(0.0f),
              type(texture)
        {
        }

        int version;                 // Version of this struct
        void* fileHandle;        // If NULL, the file could not be acquired
        int nchannels;               // The # of channels in the texture
        unsigned char* channelTypes; // The types of the channels
                                     // 0 - unknown
                                     // 1 - 8  bit
                                     // 2 - 16 bit
                                     // 3 - 32 bit
                                     // 4 - float
                                     // 5 - half
        int nparts;                  // The number of parts present
        int width, height;           // Width and height of texture
        float pixelAspectRatio;      // Pixel aspect ratio of texture
        TextureType type;            // What type of texture?
    };

    enum TxAtlasStyle
    {
        AtlasNone=0,
        AtlasUdim,
        AtlasUvTile1,
        AtlasUvTile0
    };

    struct TxParams
    {
    public:
        enum FilterType
        {
            Nearest = 0,  // *WARNING* disables MIPMAP! No filtering
            Box,          // Fast "box" like filter
            Bilinear,     // Slower, supports derivatives
            Bspline,      // Slower bicubic filter, supports derivatives
            Mitchell,     // Negative lobed, fast, bicubic filter - PTEX ONLY
            Catmullrom,   // Negative lobed, fast, bicubic filter - PTEX ONLY
            Gaussian,     // Gaussian fast filter
            Lagrangian,   // Fastest (SSE based) filter
            BsplineAniso  // Same as Bspline, but supports anisotropic filtering
        };

        TxParams()
            : version(1),
              nchannels(1),
              firstchannel(0),
              lerp(true),
              invertT(false),
              filter(Box),
              sblur(NULL),
              tblur(NULL),
              sblurVarying(true),
              tblurVarying(true),
              swidth(1.0f),
              twidth(1.0f),
              fill(0.f),
              faceIndex(NULL)
        {
        }

        int version;        // Version of this struct
        int nchannels;      // The number of channels to lookup
        int firstchannel;   // The channel to start the lookup
        bool lerp;          // Should MIP levels be interpolated
        bool invertT;       // Should the texture space origin be bottom left
                            // (false) or top left (true)
        FilterType filter;  // Which filter should be used
        const float* sblur; // Amount of blur to apply to lookup
        const float* tblur;
        bool sblurVarying;  // Is the blur uniform?
        bool tblurVarying; 
        float swidth;       // Multiplier for filter radius
        float twidth;
        float fill;         // Value to fill missing channels
        float* faceIndex;   // A faceIndex to access ptexture
    };

    virtual int AcquireTexture(
        RtUString const fileName,
        TxAtlasStyle const atlasStyle,
        TxProperties& txProperties) = 0;

    virtual int AcquireTexturePart(
        int partIndex,
        TxProperties const& txProperties,
        TxProperties& partProperties) = 0;

    virtual int ReleaseTexture(TxProperties const& txProperties) = 0;

    virtual int Texture(
        TxProperties const& txProperties,
        TxParams const& txParams,
        int nPoints,
        RtFloat2 const* st,
        float const* stRadius,
        float* result,
        int* runFlags = NULL) = 0;
    virtual int Texture(
        TxProperties const& txProperties,
        TxParams const& txParams,
        int nPoints,
        RtFloat3 const* st,
        float const* stRadius,
        float* result,
        int* runFlags = NULL) = 0;

    virtual int TextureDerivatives(
        TxProperties const& txProperties,
        TxParams const& txParams,
        int nPoints,
        RtFloat2 const* st,
        float const* dsdu,
        float const* dtdu,
        float const* dsdv,
        float const* dtdv,
        float const* dufp,
        float const* dvfp,
        float* result,
        float* dresultds,
        float* dresultdt,
        int* runFlags = NULL) = 0;
    virtual int TextureDerivatives(
        TxProperties const& txProperties,
        TxParams const& txParams,
        int nPoints,
        RtFloat3 const* st,
        float const* dsdu,
        float const* dtdu,
        float const* dsdv,
        float const* dtdv,
        float const* dufp,
        float const* dvfp,
        float* result,
        float* dresultds,
        float* dresultdt,
        int* runFlags = NULL) = 0;

    virtual int Ptexture(
        TxProperties const& txProperties,
        TxParams const& txParams,
        int nPoints,
        RtFloat2 const* uv,
        float const* uWidth,
        float const* vWidth,
        float* result,
        int* runFlags = NULL) = 0;

    virtual int PtextureDerivatives(
        TxProperties const& txProperties,
        TxParams const& txParams,
        int nPoints,
        RtFloat2 const* st,
        float const* dsdu,
        float const* dtdu,
        float const* dsdv,
        float const* dtdv,
        float* result,
        float* dresultds,
        float* dresultdt,
        int* runFlags = NULL) = 0;

    //  NOTE: No filtering is applied to the data being read.
    virtual int TextureData(
        TxProperties const& txProperties,
        TxParams const& txParams,
        int mipLevel,
        int cubeFace,
        void* result) = 0;

    virtual int GetProperty(
        TxProperties const& txProperties,
        RtUString const propertyName,
        void* result,
        int resultLen,
        Type* resultType,
        int* resultCount
        ) = 0;

    virtual const ErrType* GetLastError() = 0;

protected:
    RixTexture() : RixInterface(1) {}
};

class RixTexture3d : public RixInterface
{
public:
    virtual int RxTexture3dV(
        char const* filename,
        RtPoint3 point,
        RtNormal3 normal,
        float filterradius,
        int n,
        RtUString tokens[],
        void* parms[]) = 0;

    // The RxTexture3d interface takes name/value pairs through the ellipses.
    // It is important to note that names should be passed through as c-strings.
    // These are converted to unique strings internally so something to
    // note is that the vectorized API, RxTexture3dV, is likely to be more
    // efficient and scalable for names and values that can be constructed up
    // front.
    virtual int RxTexture3d(
        char const* filename,
        RtPoint3 point,
        RtNormal3 normal,
        float filterradius,
        ...) = 0;

protected:
    RixTexture3d() : RixInterface(2) {}
};

class RixShadeFunctions : public RixInterface
{
public:
    virtual float Noise(float in) = 0;
    virtual float Noise(RtFloat2 const& in) = 0;
    virtual float Noise(RtFloat3 const& in) = 0;
    virtual float Noise(RtFloat3 const& in, float inF) = 0;

    virtual RtFloat3 Noise3(float in) = 0;
    virtual RtFloat3 Noise3(RtFloat2 const& in) = 0;
    virtual RtFloat3 Noise3(RtFloat3 const& in) = 0;
    virtual RtFloat3 Noise3(RtFloat3 const& in, float inF) = 0;

    virtual float PNoise(float in, float period) = 0;
    virtual float PNoise(RtFloat2 const& in, RtFloat2 const& period) = 0;
    virtual float PNoise(RtFloat3 const& in, RtFloat3 const& period) = 0;
    virtual float PNoise(
        RtFloat3 const& in,
        float inF,
        RtFloat3 const& period,
        float periodF) = 0;

    virtual RtFloat3 PNoise3(float in, float period) = 0;
    virtual RtFloat3 PNoise3(RtFloat2 const& in, RtFloat2 const& period) = 0;
    virtual RtFloat3 PNoise3(RtFloat3 const& in, RtFloat3 const& period) = 0;
    virtual RtFloat3 PNoise3(
        RtFloat3 const& in,
        float inF,
        RtFloat3 const& period,
        float periodF) = 0;

    virtual float CellNoise(float in) = 0;
    virtual float CellNoise(RtFloat2 const& in) = 0;
    virtual float CellNoise(RtFloat3 const& in) = 0;
    virtual float CellNoise(RtFloat3 const& in, float inF) = 0;

    virtual RtFloat3 CellNoise3(float in) = 0;
    virtual RtFloat3 CellNoise3(RtFloat2 const& in) = 0;
    virtual RtFloat3 CellNoise3(RtFloat3 const& in) = 0;
    virtual RtFloat3 CellNoise3(RtFloat3 const& in, float inF) = 0;

    enum SplineType
    {
        Bezier = 0,
        BSpline,
        Hermite,
        Linear,
        Catmullrom
    };

    virtual float SolveSpline(
        SplineType type,
        float const knot[],
        int nKnots,
        float a) = 0;
    virtual float EvalSpline(
        SplineType type,
        float const knot[],
        int nKnots,
        float a) = 0;
    virtual RtFloat3 EvalSpline3(
        SplineType type,
        RtFloat3 const knot[],
        int nknot,
        float a) = 0;

protected:
    RixShadeFunctions() : RixInterface(1) {}
};

class RixTransform : public RixInterface
{
public:
    virtual int TransformPoints(
        RtUString const fromspace,
        RtUString const tospace,
        int n,
        RtPoint3 p[],
        float time) = 0;

    virtual void TransformPoints(RtMatrix4x4 const& m, int n, RtPoint3 p[]) = 0;

    virtual int TransformMatrix(
        RtUString const fromspace,
        RtUString const tospace,
        float time,
        RtMatrix4x4& m) = 0;

protected:
    RixTransform() : RixInterface(1) {}
};
  
class RixRenderState : public RixInterface
{
public:
    struct RendererInfo
    {
        const char* renderer;
        const char* version;
        int versionCode[4];
        char _reserved[32];
    };
    virtual int GetRendererInfo(RendererInfo*) = 0;

    struct FrameInfo
    {
        FrameInfo() : _vers(2) {}

        enum t_displayStyle
        {
            k_partialPixels,
            k_finalPixels
        };

        int frame;
        int nthreads;
        float shutter[2]; // when shutter values are equal, no motion-blur
        bool rerendering;
        struct
        {
            int nDisplays; // indexes for GetDspyInfo
            int resolution[2];
            t_displayStyle displayStyle;
        } displayState;

        int _vers;

        // added in version 2
        // integrator settings are only non-null in RIS mode
        RtUString integratorName;
        RtUString integratorPath;
        class RixIntegratorEnvironment const* integratorEnv;

        char _reserved[32];
    };

    virtual int GetFrameInfo(FrameInfo*) = 0;

    struct DspyInfo
    {
        RtUString name;
        RtUString type;
        RtUString mode;
        char _reserved[32];
    };
    virtual int GetDspyInfo(int dspyId, DspyInfo*) = 0;

    enum ShadingIntent
    {
        k_siInvalid = 0,
        k_siShadeGrid,
        k_siShadeRay,
        k_siCache,
        k_siNumShadingIntents
    };

    struct RayCtxInfo
    {
        int integratorIteration; // always 0 when in distribution integration
        char _reserved[32];
    };

    virtual int GetRayCtxInfo(RayCtxInfo*) = 0;

    virtual int GetOption(
        RtUString const name,
        void* result,
        int resultLength,
        Type* resultType,
        int* resultCount) = 0;

    virtual int GetAttribute(
        RtUString const name,
        void* result,
        int resultLength,
        Type* resultType,
        int* resultCount) = 0;

    virtual int GetRIBFileContext(int* linenumber, char** filename) = 0;

    
    virtual int GetRIBArchive(RtUString const filename, const char** archive) = 0;

protected:
    RixRenderState() : RixInterface(3) {}
};

class [[deprecated]] RixSymbolResolver : public RixInterface
{
public:
    virtual void ResolvePredefinedStrings(RiPredefinedStrings &ps) const = 0;

    enum SymbolGroup
    {
        k_PixelFilter  = 0,
        k_Basis        = 1,
        k_Procedural   = 2,
        k_ErrorHandler = 3,
        k_RiEntryPoint = 4
    };
    //
    virtual void* ResolveSymbol(const char* nm, SymbolGroup group) = 0;

protected:
    RixSymbolResolver() : RixInterface(1) {}
};


class RixGeoDebugger : public RixInterface
{
public:
    virtual void EmitVector(RtVector3 v, RtColorRGB c) = 0;
    virtual void EmitPoint(RtPoint3 p, RtColorRGB c) = 0;
    virtual void EmitPointNormal(RtPoint3 p, RtNormal3 n, RtColorRGB c) = 0;
    virtual void EmitLine(RtPoint3 p1, RtPoint3 p2, RtColorRGB c) = 0;
    virtual void EmitBound(RtPoint3 pmin, RtPoint3 pmax, RtColorRGB c) = 0;
    virtual void Clear() = 0;
    virtual void Flush() = 0;

protected:
    RixGeoDebugger() : RixInterface(1) {}
};

typedef int RixLPEToken;

class RixLPEInfo : public RixInterface
{
public:
    virtual int GetLpeIdByName(
        bool discrete,
        bool specular,
        bool reflect,
        bool user,
        unsigned char lobeId,
        char const* name) const = 0;

    virtual int GetNumPotentialDiffuseLobes() const = 0;
    virtual int GetNumPotentialSpecularLobes() const = 0;
    virtual int GetNumPotentialUserLobes() const = 0;

protected:
    RixLPEInfo() : RixInterface(1) {}
};

// This is a callback routine for use with the
// RixCustomLPE::RegisterScatterCallback() and
// RixCustomLPE::InvokeScatterCallbacks(), described in more detail below.
typedef void (*RixLPECallback)(
    void* userData,
    RixLPEState* lpeState,
    RixShadingContext const* sCtx,
    int sCtxIndex,
    RtColorRGB const& thruput,
    RtColorRGB const* lightTrans,
    bool firstContribution);

class RixCustomLPE : public RixInterface
{
public:
    // Use this method to return an integer identifier that corresponds to
    // a given Light Path Expression (LPE).
    virtual int LookupLPE(char const* lpeExpr) = 0;

    // Use this method to return an integer identifier that corresponds to
    // a given Light Path Expression (LPE) name.
    virtual int LookupLPEByName(char const* lpeName) = 0;

    // This method returns true if the 'customLpe' integer identifier
    // (which should be obtained by calling LookupLPE()) matches the current
    // ray hit, returning true or false along with the cumulative path
    // thruput corresponding to the custom LPE. This method should typically
    // be called from within a registered "transition" callback routine
    // (see RegisterScatterCallback() below).
    virtual bool MatchesLPE(
        int customLpe,
        RixLPEState* lpeState,
        RtColorRGB& thruput) = 0;

    // Use this method to register a "scatter" callback. Each scattering
    // event along the ray path counts as a "scatter" event (that is, each
    // ray-geometry intersection hit point that results in light being
    // scattered throughout the scene). Ater registering a scatter callback,
    // the callback routine will be invoked at each scattering event. Within
    // a scatter callback routine one might make a call to the MatchesLPE()
    // method in order to determine whether a particular custom LPE matches
    // the current ray path history.
    virtual void RegisterScatterCallback(
        RixLPECallback callbackFunc,
        void* userData = NULL) = 0;

    // Calling this method will invoke all registered scatter callback routines.
    // Typically this method is only called internally by the core rendering
    // code (and typically end-user code would not need to call this method
    // directly). Instead this routine is called indirectly via the RixLPE
    // interface whenever there is a scattering event.
    virtual void InvokeScatterCallbacks(
        RixLPEState* lpeState,
        RixShadingContext const* sCtx,
        int sCtxIndex,
        RtColorRGB const& thruput,
        RtColorRGB const* lightTrans,
        bool firstContribution) = 0;

protected:
    RixCustomLPE() : RixInterface(2) {}
};

class RixXmlFile
{
public:
    virtual void WriteXml(const char* format, ...) = 0;

    virtual void WriteText(const char* format, ...) = 0;

    virtual ~RixXmlFile() {}

    // Helper functions for writings stats.
    void WriteStat(char const* name, char const* desc, int value)
    {
        WriteXml("<int name=\"%s\"", name);
        if (desc)
            WriteXml(" description=\"%s\"", desc);
        WriteXml("> %i </int>\n", value);
    }

    void WriteStat(char const* name, char const* desc, uint64_t value)
    {
        WriteXml("<int name=\"%s\"", name);
        if (desc)
            WriteXml(" description=\"%s\"", desc);
        WriteXml("> %llu </int>\n", value);
    }

    void WriteStat(char const* name, char const* desc, float value)
    {
        WriteXml("<float name=\"%s\"", name);
        if (desc)
            WriteXml(" description=\"%s\"", desc);
        WriteXml("> %f </float>\n", value);
    }

    void WriteStat(char const* name, char const* desc, char const* value)
    {
        WriteXml("<string name=\"%s\"", name);
        if (desc)
            WriteXml(" description=\"%s\"", desc);
        WriteXml("> %s </string>\n", value);
    }

    void WriteTime(char const* name, char const* desc, float time)
    {
        WriteXml("<timer name=\"%s\"", name);
        if (desc)
            WriteXml(" description=\"%s\"", desc);
        WriteXml("><elapsed>%f</elapsed></timer>\n", time);
    }
};

class RixTimer : public RixInterface
{
public:
    virtual uint64_t SampleTime() = 0;
    virtual float ConvertIntervalToSeconds(uint64_t interval) = 0;

protected:
    RixTimer() : RixInterface(1) {}
};

class RixStats : public RixInterface
{
public:
    virtual void AddTimerStat(
        float* seconds,
        const char* name,
        const char* description) = 0;

    class SimpleStat
    {
    public:
        enum Fmt
        {
            k_fmtAsTimeInterval,
            k_fmtAsMemory,
            k_fmtAsUInt,
            k_fmtAsInt,
            k_fmtAsFloat
        };
        virtual ~SimpleStat() {}
        virtual void Reset() = 0;
        virtual const char* GetName() = 0;
        virtual const char* GetDescription() = 0;
        virtual void GetResults(uint64_t* result, Fmt* fmt) = 0;
    };
    virtual int AddSimpleStat(SimpleStat*) = 0;

    virtual void AddMemoryStat(
        size_t* bytes,
        const char* name,
        const char* description) = 0;

    typedef void (*Reporter)(class RixXmlFile* file);
    typedef void (*ReporterCtx)(void* ctx, class RixXmlFile*);

    virtual void AddReporter(Reporter func) = 0;
    virtual void AddReporterCtx(ReporterCtx func, void* ctx) = 0;

    virtual void AddFileLogStat(const char* fileName, const char* path) = 0;

protected:
    RixStats() : RixInterface(3) {}
};


class [[deprecated]] RixResourceResolver : public RixInterface
{
public:
    enum ResourceType
    {
        k_Shader = 0,
        k_Texture,
        k_Archive,
        k_Display,
        k_Procedural,
        k_RifFilter,
        k_RixPlugin
    };

    virtual char const* GetResourcePaths(ResourceType) = 0;

    virtual int ResolveResource(
        ResourceType,
        char const* nm,
        char result[],
        int maxlen) = 0;

protected:
    RixResourceResolver() : RixInterface(1) {}
};

[[deprecated]] typedef void (*RixCleanupFunc)(RixContext* context, void* data);

class [[deprecated]] RixStorage : public RixInterface
{
public:
    virtual void* Get(const RtUString key) = 0;

    virtual void Set(
        const RtUString key,
        void* data,
        RixCleanupFunc cleanup = NULL) = 0;

    virtual void Clear(const RtUString key) = 0;

    virtual void Lock() = 0;

    virtual void Unlock() = 0;

protected:
    RixStorage() : RixInterface(1) {}
};

template<typename _Signature>
class RixFunction;

template <typename _Res, typename... _ArgTypes>
class [[deprecated]] RixFunction<_Res(_ArgTypes...)>
{
    struct FunctionPrototype
    {
        virtual ~FunctionPrototype() {}
        virtual _Res operator()(_ArgTypes... __args) const = 0;
    };

    template< typename Closure >
    struct Function : FunctionPrototype
    {
        Function(Closure&& t ) : fn(t) {}
        virtual ~Function() {}
        virtual _Res operator()(_ArgTypes... __args) const
        { return fn(__args...); }
        Closure fn;
    };

    FunctionPrototype* object;

public:
    template< typename Closure >
    RixFunction(Closure&& obj )
        : object( new Function<Closure>( std::move(obj) ) )
    {}

    ~RixFunction()
    { delete object; }

    _Res operator()(_ArgTypes... __args) const
    {
        return (*object)(__args...);
    }
};

class [[deprecated]] RixMutex
{
public:
    virtual ~RixMutex() {}

    virtual void Lock() = 0;

    virtual void Unlock() = 0;
};

class [[deprecated]] RixThreadUtils : public RixInterface
{
public:
    virtual RixMutex* NewMutex() const = 0;

    virtual void DeleteMutex(RixMutex *mutex) const = 0;
    
    virtual void ParallelFor(size_t start, size_t end,
                             const RixFunction<void(size_t)>& fn) const = 0;
    virtual void ParallelFor(size_t start, size_t end, size_t step,
                             const RixFunction<void(size_t)>& fn) const = 0;

protected:
    RixThreadUtils() : RixInterface(1) {}
};



#endif // RIX_INTERFACE_H