RixInterfaces.h

/* $Revision: #58 $  (Pixar - RenderMan Division) $Date: 2010/11/04 $ */
/*
# ------------------------------------------------------------------------------
#
# Copyright (c) 2006-2010 Pixar Animation Studios. All rights reserved.
#
# The information in this file is provided for the exclusive use of the
# software licensees of Pixar.  It is UNPUBLISHED PROPRIETARY SOURCE CODE
# of Pixar Animation Studios; the contents of this file 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 Animation Studios.
# Use of copyright notice is precautionary and does not imply publication.
#
# 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.
#
# Pixar
# 1200 Park Ave
# Emeryville CA 94608
#
# ------------------------------------------------------------------------------
*/

#ifndef RIX_INTERFACE_H
#define RIX_INTERFACE_H

#include "ri.h"
#include <vector>

#include <stddef.h>             // for size_t
#include <string>

enum RixInterfaceId {
    k_RixThreadUtils = 0,
    k_RixMessages,      
    k_RixStats,         
    k_RixGlobalData,    
    k_RixThreadData,    
    k_RixLocalData,     
    k_RixGlobalTokenData,
    // Slot 7 is version 1 of the RixSubdivisionSurfaceEvaluation interface, do not use
    k_RixSessionData = 8,   
    k_RixXcpt,          
    k_RixRIB,           
    k_RixDeepTexture,    
    k_RixSubdivisionSurfaceEvaluation, 
    
};

class RixInterface {
public:
    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;

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

class RixMutex {
public:
    virtual ~RixMutex() { }

    virtual void Lock() = 0;
    
    virtual void Unlock() = 0;
};


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

protected:
    RixThreadUtils() : 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 RixStats : public RixInterface {
public:
    virtual void AddTimerStat(float* seconds, const char* name,
                              const char* description) = 0;

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

    typedef void (*Reporter)(class RixXmlFile* file);

    virtual void AddReporter(Reporter func) = 0;

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

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


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

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

    virtual ~RixXmlFile() { }
};


typedef void (*RixCleanupFunc)(RixContext* context, void* data);


class RixStorage : public RixInterface {
public:
    virtual void* Get(const char* key) = 0;

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

    virtual void Clear(const char* key) = 0;

    virtual void Lock() = 0;

    virtual void Unlock() = 0;

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


class RixTokenStorage : public RixInterface {
public:
    virtual const char *GetToken(const char *input) = 0;

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


extern "C" {
    PRMANAPI class RixSubdivisionSurfaceEvaluation *RixGetSubdivInterface(int version);
    PRMANAPI class RixContext *RixGetContext();
}

#endif  // RIX_INTERFACE_H

---