RslPlugin.h

Go to the documentation of this file.

/* $Id: //depot/main/rmanprod/rman/include/shadeop.h#18 $  (Pixar - RenderMan Division) $Date: 2005/06/02 $ */
/*
** Copyright (c) 2004 PIXAR.  All rights reserved.  This program or
** documentation contains proprietary confidential information and trade
** secrets of PIXAR.  Reverse engineering of object code is prohibited.
** Use of copyright notice is precautionary and does not imply
** publication.
**
**                      RESTRICTED RIGHTS NOTICE
**
** Use, duplication, or disclosure by the Government is subject to the
** following restrictions:  For civilian agencies, subparagraphs (a) through
** (d) of the Commercial Computer Software--Restricted Rights clause at
** 52.227-19 of the FAR; and, for units of the Department of Defense, DoD
** Supplement to the FAR, clause 52.227-7013 (c)(1)(ii), Rights in
** Technical Data and Computer Software.
**
** Pixar
** 1200 Park Ave.
** Emeryville, CA  94608
*/

#ifndef RSLPLUGIN_H
#define RSLPLUGIN_H

// Use of typedefs like RtColor is recommended for new grid-based shadeops.
// For backwards compatibility, they are not automatically included for older
// pointwise shadeops.
#include "ri.h"
#include "RixInterfaces.h"      // RslContext inherits from RixContext

#define RSL_PLUGIN_VERSION 2



typedef unsigned int RslRunFlag;

typedef unsigned int RslIncrType;

typedef int (*RslEntryFunc)(class RslContext* ctx,
                            int argc, const class RslArg** argv);

class RslContext : public RixContext {
public:
    virtual ~RslContext() {}

    virtual const RslRunFlag* GetRunFlags(unsigned int* length) const = 0;

    virtual RixInterface* GetRixInterface(RixInterfaceId id) const = 0;

    RixStorage* GetGlobalStorage() const
    {
        return (RixStorage*) GetRixInterface(k_RixGlobalData);
    }

    RixStorage* GetThreadStorage() const
    {
        return (RixStorage*) GetRixInterface(k_RixThreadData);
    }

    RixStorage* GetLocalStorage() const
    {
        return (RixStorage*) GetRixInterface(k_RixLocalData);
    }

    void SetThreadData(void* data, RixCleanupFunc cleanup = 0L)
    {
        RixStorage* storage = (RixStorage*) GetRixInterface(k_RixThreadData);
        storage->Set(GetPluginName(), data, cleanup);
    }

    void* GetThreadData() const
    {
        RixStorage* storage = (RixStorage*) GetRixInterface(k_RixThreadData);
        return storage->Get(GetPluginName());
    }

    void SetLocalData(void* data, RixCleanupFunc cleanup = 0L)
    {
        RixStorage* storage = (RixStorage*) GetRixInterface(k_RixLocalData);
        storage->Set(GetPluginName(), data, cleanup);
    }

    void* GetLocalData() const
    {
        RixStorage* storage = (RixStorage*) GetRixInterface(k_RixLocalData);
        return storage->Get(GetPluginName());
    }

    virtual const char* GetPluginName() const = 0;

private:
    // Need to call private methods from iterator constructors.
    template<typename T> friend class RslIter;
    template<typename T> friend class RslArrayIter;

    // Get acceleration info for an iterator with "packed" user data.
    virtual RslIncrType* getIncrList(unsigned int stride) const = 0;
};

class RslArg {
public:
    virtual ~RslArg() {};

    virtual bool IsFloat() const = 0;

    virtual bool IsPoint() const = 0;

    virtual bool IsVector() const = 0;

    virtual bool IsColor() const = 0;

    virtual bool IsString() const = 0;

    virtual bool IsMatrix() const = 0;

    virtual bool IsArray() const = 0;

    virtual bool IsVarying() const = 0;

    virtual int GetArrayLength() const = 0;

    virtual unsigned int NumValues() const = 0;

    static unsigned int NumValues(int argc, const RslArg** argv) {
        int m = 1;
        for (int i = 0; i < argc; ++i) {
            int n = argv[i]->NumValues();
            if (n > m)
                m = n;
        }
        return m;
    }

    virtual void GetData(float** data, int* stride) const = 0;

private:
    // Need to call private methods from iterator constructors.
    template<typename T> friend class RslIter;
    template<typename T> friend class RslArrayIter;

    // Returns (in result parameters) the data pointer and increment list.
    virtual void getInfo(float** data, RslIncrType** incrList,
                 bool* isVarying) const = 0;

    // Returns (in result parameters) the data pointer, increment list, and
    // array length.
    virtual void getArrayInfo(float** data,
                      RslIncrType** incrList, int* arrayLength,
                      bool* isVarying) const = 0;
};


template<typename T>
class RslIter {
public:
    RslIter(const RslArg* arg)
    {
        arg->getInfo(&m_data, &m_incrList, &m_isVarying);
    }

    RslIter(const T* data, const RslContext* ctx) :
        m_data((float*) data),
        m_incrList(ctx->getIncrList(0)),
        m_isVarying(false)
    {
    }

    T& operator*() { return *((T*) m_data); }

    const T& operator*() const { return *((T*) m_data); }

    RslIter<T>& operator++() 
    {
        m_data += *m_incrList;
        ++m_incrList;
        return *this;
    };

    RslIter<T> operator++(int) 
    {
        RslIter<T> temp = *this;                // Copy before increment.
        ++*this;                        // Increment.
        return temp;                    // Return old value.
    };

    bool IsVarying() const { return m_isVarying; }

private:
    // Current data pointer.
    float* m_data;

    // Current increment list, which gives fast access to next active point.
    RslIncrType* m_incrList;

    // True if the iterator is varying.
    bool m_isVarying;
};
    

template<typename T>
class RslArrayIter {
public:
    RslArrayIter(const RslArg* arg)
    {
        arg->getArrayInfo(&m_data, &m_incrList, &m_length, &m_isVarying);
    }

    RslArrayIter(const T* data, int length, const RslContext* ctx) :
        m_data((float*) data),
        m_incrList(ctx->getIncrList(0)),
        m_length(length),
        m_isVarying(false)
    {
    }
    T* operator*() { return (T*) m_data; }

    T&  operator[](int x) { return ((T*)m_data)[x]; }

    RslArrayIter<T>& operator++() 
    {
        m_data += *m_incrList * m_length;
        ++m_incrList;
        return *this;
    };

    RslArrayIter<T> operator++(int) 
    {
        RslArrayIter<T> temp = *this;   // Copy before increment.
        ++*this;                        // Increment.
        return temp;                    // Return old value.
    };
        
    bool IsVarying() const { return m_isVarying; }

    int GetLength() const { return m_length; }
        
private:
    // Current data pointer.
    float* m_data;

    // Current increment list, which gives fast access to next active point.
    RslIncrType* m_incrList;

    // Array length.
    int m_length;

    // True if the iterator is varying.
    bool m_isVarying;
};


typedef RslIter<RtFloat>        RslFloatIter;        
typedef RslIter<RtString>       RslStringIter;       
typedef RslIter<RtColor>        RslColorIter;        
typedef RslIter<RtVector>       RslVectorIter;       
typedef RslIter<RtNormal>       RslNormalIter;       
typedef RslIter<RtPoint>        RslPointIter;        
typedef RslIter<RtMatrix>       RslMatrixIter;       

typedef RslArrayIter<RtFloat>   RslFloatArrayIter;   
typedef RslArrayIter<RtString>  RslStringArrayIter;  
typedef RslArrayIter<RtColor>   RslColorArrayIter;   
typedef RslArrayIter<RtVector>  RslVectorArrayIter;  
typedef RslArrayIter<RtNormal>  RslNormalArrayIter;  
typedef RslArrayIter<RtPoint>   RslPointArrayIter;    
typedef RslArrayIter<RtMatrix>  RslMatrixArrayIter;   
    

typedef void (*RslVoidFunc)(RixContext* context);

struct RslFunction {
    const char *m_prototype;

    RslEntryFunc m_entry;

    RslVoidFunc m_initFunc;

    RslVoidFunc m_cleanupFunc;
};

struct RslFunctionTable {
    const RslFunction* m_functions;

    const char m_version;

    RslVoidFunc m_initFunc;

    RslVoidFunc m_cleanupFunc;

    RslFunctionTable(const RslFunction* functions,
                     RslVoidFunc init = NULL, RslVoidFunc cleanup = NULL) :
        m_functions(functions),
        m_version(RSL_PLUGIN_VERSION),
        m_initFunc(init),
        m_cleanupFunc(cleanup)
    {
    }
};

#ifdef _MSC_VER
#define RSLEXPORT __declspec(dllexport)
#else
#define RSLEXPORT
#endif

#endif /* defined RSLPLUGIN_H */

---