RslPlugin.h

Go to the documentation of this file.

/* $Revision: #1 $  (Pixar - RenderMan Division)       $Date: 2015/04/23 $ */
/*
# ------------------------------------------------------------------------------
#
# Copyright (c) 2006-2010 Pixar Animation Studios. All rights reserved.
#
# The information in this file (the "Software") is provided for the
# exclusive use of the software licensees of Pixar.  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 Animation Studios.
#
# 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.
#
# 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 7

typedef unsigned int RslRunFlag;

typedef unsigned int RslIncrType;

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

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

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

    virtual bool HasAuxiliaryPoints() const = 0;
};

class RslContext : public RslContext_v2 {
public:
    virtual ~RslContext() {};
};

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

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;

    // OBSOLETE: The layout of array data has changed in version 5.
    // 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;
};

// NOTE:
//    This is a shim class to provide compatabiliy with
//    v5 of the RslArg interface. Due to a cut/paste
//    error in a previous release, some private methods 
//    from RslArg_v5 were aliased against the actual
//    RslArg interface.
class RslArg_v6 : public RslArg_v5
{
public:
    virtual ~RslArg_v6() {};

    // Note these are the actual methods that were resolved
    // instead of the ones defined in RslArg_v5
private:
    // Need to call private methods from various constructors.
    friend class RslStruct;
    friend class RslStructArray;
    template<typename T> friend class RslArrayIter;

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

    // OBSOLETE: The layout of array data has changed in version 5.
    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;
};

class RslArg_v7 : public RslArg_v6
{
public:

    virtual bool IsFilterRegion() const = 0;

    virtual ~RslArg_v7() {};
};

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

};


// 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);
        m_dataStart = m_data;
        m_incrListStart = m_incrList;
    }

    RslIter(const T* data, const RslContext* ctx) :
        m_data((float*) data),
        m_dataStart((float*) data),
        m_incrList(ctx->getIncrList(0)),
        m_incrListStart(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.
    };

    void Reset()
    {
        m_data = m_dataStart;
        m_incrList = m_incrListStart;
    }

    bool IsVarying() const { return m_isVarying; }

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

    // The reset to the start data pointer.
    float* m_dataStart;

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

    // The reset to the start increment list pointer.
    RslIncrType* m_incrListStart;

    // 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_stride, &m_isVarying);

        m_dataStart = m_data;
        m_incrListStart = m_incrList;
    }

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

    // Default constructor
    RslArrayIter() :
        m_data(NULL),
        m_dataStart(NULL),
        m_incrList(NULL),
        m_incrListStart(NULL),
        m_length(0),
        m_capacity(0),
        m_stride(0),
        m_isVarying(false)
    { 
    }

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

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

    RslArrayIter<T> operator++(int) 
    {
        RslArrayIter<T> temp = *this;   // Copy before increment.
        ++*this;                        // Increment.
        return temp;                    // Return old value.
    }; 
    
    void Reset(int index=0)
    {
        m_data = (float *)&((T*)m_dataStart)[index * m_stride];
        m_incrList = m_incrListStart;
    }
 
    bool IsVarying() const { return m_isVarying; }

    int GetLength() const { return m_length; }
        
    int GetCapacity() const { return m_capacity; }

    int GetStride() const { return m_stride; }

#ifndef RSL_ALLOW_ARRAY_DEREF
private:
#endif
    T* operator*() { return (T*) m_data; }
        
private:
    // Current data pointer.
    float* m_data;

    // The reset to the start data pointer.
    float* m_dataStart;

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

    // The reset to the start increment list pointer.
    RslIncrType* m_incrListStart;

    // Array length.
    int m_length;

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

    // The stride to get to the next array element
    int m_stride;

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

template<>
inline RslArrayIter<RtMatrix>&
RslArrayIter<RtMatrix>::operator++() 
{
    m_data += *m_incrList * 16;
    ++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 RslIter<RtMatrix>       RslFilterRegionIter; 
                                                     // data layout as RtMatrix

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 */