RslPlugin.h

Go to the documentation of this file.

/* $Revision: #67 $  (Pixar - RenderMan Division)       $Date: 2008/12/08 $ */
/*
** Copyright (c) 2006 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
#include <stdarg.h>
#include <assert.h>
#include <string>

#define RSL_PLUGIN_VERSION 5



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_v2 {
public:
    virtual ~RslArg_v2() {};

    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 class RslArg** argv);

    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;
};


class RslArg_v3 : public RslArg_v2
{
public:
    virtual bool IsNormal() const = 0;

    virtual bool IsWriteable() const = 0;

    virtual ~RslArg_v3() {};
};


class RslArg : public RslArg_v3
{
public:
    virtual bool IsStruct() const = 0;

    virtual const char* GetName() const = 0;

    virtual bool IsResizable() const = 0;

    virtual class RslResizer* GetResizer() const = 0;

    virtual ~RslArg() {};

private:
    // Need to call private methods from various constructors.
    friend class RslStruct;
    friend class RslStructArray;
    template<typename T> friend class RslArrayIter;


    // Get struct data pointer, along with array length and stride.
    virtual float* getStructData(int* length,
                                 unsigned int* stride) const = 0;

    // Get struct info.  Returns RslArgs for struct members.
    virtual const RslArg** getStructInfo(float* data,
                                         const char** name, 
                                         unsigned int* numMembers) const = 0;

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

    // Obsolete version of getArrayInfo, which doesn't return capacity.
    virtual void getArrayInfo(float** data,
                              RslIncrType** incrList, int* arrayLength,
                              bool* isVarying) const = 0;
};


// Implementation of RslArg_v2::NumValues must follow definition of RslArg.
inline unsigned int 
RslArg_v2::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;
}


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<>
inline RslIter<RtMatrix>&
RslIter<RtMatrix>::operator++() 
{
    m_data += *m_incrList * 16;
    ++m_incrList;
    return *this;
}


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

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

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

    T&  operator[](int x) 
    {
        assert(x >= 0 && x < m_length);
        return ((T*)m_data)[x]; 
    }

    RslArrayIter<T>& operator++() 
    {
        m_data += *m_incrList * m_capacity;
        ++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; }
        
    int GetCapacity() const { return m_capacity; }
        
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;

    // Array capacity, which is the same as the length unless it's resizable.
    int m_capacity;

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


template<>
inline RslArrayIter<RtMatrix>&
RslArrayIter<RtMatrix>::operator++() 
{
    m_data += *m_incrList * 16 * m_length;
    ++m_incrList;
    return *this;
}

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;   

class RslResizer {
public:
    virtual unsigned int GetLength() const = 0;

    virtual unsigned int GetCapacity() const = 0;

    virtual void Resize(unsigned int n) = 0;

    virtual void Reserve(unsigned int n) = 0;

protected:
    virtual ~RslResizer() { }
};


class RslStruct {
public:
    RslStruct(const RslArg* arg)
    {
        assert(arg->IsStruct() && !arg->IsArray());
        int length;
        unsigned int stride;
        float* data = arg->getStructData(&length, &stride);
        m_members = arg->getStructInfo(data, &m_name, &m_numMembers);
    }

    const char* GetName() const { return m_name; }

    unsigned int GetNumMembers() const { return m_numMembers; }

    const RslArg* operator[](int i) const
    {
        assert(i >= 0 && (unsigned int) i < m_numMembers); 
        return m_members[i];
    }

private:
    // Struct members
    const RslArg** m_members;

    // Struct type name.
    const char* m_name;

    // Number of struct members.
    unsigned int m_numMembers;

    // RslStructArray calls a private constructor.
    friend class RslStructArray;

    // Private constructor
    RslStruct(const RslArg* arg, float* data)
    {
        m_members = arg->getStructInfo(data, &m_name, &m_numMembers);
    }
};


class RslStructArray {
public:
    RslStructArray(const RslArg* arg)
    {
        assert(arg->IsArray() && arg->IsStruct());
        m_array = arg;
        m_data = arg->getStructData(&m_length, &m_stride);
    }

    RslStruct operator[](int i) const
    {
        assert(i >= 0 && i < m_length);
        return RslStruct(m_array, m_data + i * m_stride);
    }

    int GetLength() const { return m_length; }

private:
    // RslArg that represents the array.
    const RslArg* m_array;

    // Data pointer.
    float* m_data;

    // Array length.
    int m_length;

    // Stride for array index calculations (in words)
    unsigned int m_stride;
};


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

struct RslFunction {
    const char *m_prototype;

    RslEntryFunc m_entry;

    RslVoidFunc m_initFunc;

    RslVoidFunc m_cleanupFunc;
    
    RslVoidFunc m_renderBeginFunc;
    
    RslVoidFunc m_renderEndFunc;
};

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)
    {
    }
};

#endif /* defined RSLPLUGIN_H */