SHOP/SHOP_Clerk.h

Go to the documentation of this file.

/*
 * PROPRIETARY INFORMATION.  This software is proprietary to
 * Side Effects Software Inc., and is not to be reproduced,
 * transmitted, or disclosed in any way without written permission.
 *
 * Produced by:
 *      Side Effects Software Inc
 *      477 Richmond Street West
 *      Toronto, Ontario
 *      Canada   M5V 3E7
 *      416-504-9876
 *
 * NAME:        SHOP_Clerk.h ( SHOP Library, C++)
 *
 * COMMENTS:    Defines a mapping from SHOP parameters to a renderer.
 *
 */

#ifndef __SHOP_Clerk__
#define __SHOP_Clerk__

#include "SHOP_API.h"
#include <UT/UT_String.h>
#include "SHOP_NodeTypes.h"

class UT_WorkBuffer;
class UT_Options;
class UT_BoundingBox;
class PRM_Template;
class OP_Context;
class SHOP_Node;
class SHOP_Data;
class SHOP_ReData;

class SHOP_API SHOP_Clerk {
public:
             SHOP_Clerk();
    virtual ~SHOP_Clerk();

    //
    // This render name should match the name in the IFD class.  That is, this
    // should be the type of renderer passed in for evaluation.
    // The label is a string which can be used to describe the renderer.
    // Typically, this string is used in menus in the UI.  For example:
    //
    //    getRenderName()       { return "RIB"; }
    //    getRenderLabel()      { return "RenderMan V3.7"; }
    //
    virtual const char          *getRenderName() const = 0;
    virtual const char          *getRenderLabel() const;
    virtual const char          *getDefaultKeywords() const;

    virtual int                  getDialogScriptEnum(SHOP_TYPE type) const;

    virtual bool                 generatesString() const;
    virtual bool                 requireAutoAdd(SHOP_TYPE type) const;

    // Typically this data is a string.  However, there are no restrictions.
    // The data returned is owned by the SHOP and should be destroyed when the
    // SHOP_Clerk is destroyed.  The renderer will not destruct it.
    virtual SHOP_Data   *buildRenderData(SHOP_Node *node,
                                         fpreal now,
                                         int fprecision);

    // By default, the buildGeometryData will just return the buildRenderData.
    // In the case where the render data is string data, this is ok.  However,
    // if something different needs to be built, the method can be overridden.
    virtual SHOP_Data   *buildGeometryData(SHOP_Node *node,
                                           fpreal now,
                                           int fprecision);

    virtual bool         buildShaderData(SHOP_Node *node,
                                            SHOP_ReData &data,
                                            fpreal now,
                                            const UT_Options *options);
    virtual bool         buildShaderString(SHOP_Node *node,
                                            UT_String &shader,
                                            fpreal now,
                                            const UT_Options *options);
    virtual bool         buildShaderBounds(SHOP_Node *node,
                                            UT_BoundingBox &box,
                                            fpreal now,
                                            const UT_Options *options);

    // If the geometry data is different than the render data, the
    // differentGeometryData() method MUST return 1 (it returns 0 by default).
    virtual bool         differentGeometryData() const;

    // When evaluating geometry shaders, the clerk may need to evaluate
    // bounding box information.  Particularly for RIB and VMantra.
    virtual bool         getBoundingBox(UT_BoundingBox &box,
                                         SHOP_Node &node, OP_Context &ctx);

    //
    // When attaching the shader information to a primitive, the shader
    // information must be able to be stored as a string.  In this case, we
    // need to define the attribute name as well as how to build the string.
    //
    // If the attribute cannot be attached to geometry, then the
    // getGeometryAttribute() function should return a null pointer.
    // By default, this is what the getGeometryAttribute() does.
    //
    // The GeometryIndirect returns the name of an indirect attribute which
    // causes the SHOP to be evaluated at render time.
    //
    virtual const char  *getGeometryAttribute(SHOP_TYPE shader_type) const;
    virtual const char  *getGeometryIndirect(SHOP_TYPE shader_type) const;

    // Return true if we are the VEX clerk.  Returns false by default.
    virtual bool        getIsVexClerk() const;

    // A creation script gets run when the SHOP has it's creation script run.
    // This allow the clerk to add spare properties to the SHOP if required.
    virtual const char  *getCreationScript(SHOP_TYPE shader_type) const;

protected:
    virtual void        buildShaderStart(UT_String &str,
                                         const char *shader_name,
                                         SHOP_Node *node);
    virtual void        buildShaderEnd(UT_String &str,
                                         const char *shader_name,
                                         SHOP_Node *node);

    // Evaluate the bounding box specified by the path to the OP_Node.
    bool                evalSopBoundingBox(UT_BoundingBox &box,
                                           SHOP_Node &node,
                                           const char *parmname,
                                           fpreal now);

    // This function is used by the default "buildRenderData()" method to build
    // data for a string representation of the shader data.  It generates data
    // of the form:
    //          parm_name ( parm_value1 parm_value2 ... )
    // This is the type of data expected by VEX.
    // The string generated should be for the parameter specified only (not
    // include other parameters).
    // This should return 1 on success or 0 on failure.
    // The template passed in will be the template for the parameter desired
    // parameter (not the start of the list).
    virtual int         buildParmCommand(UT_WorkBuffer &parm_data,
                                         SHOP_Node *node,
                                         PRM_Template *tplate,
                                         fpreal now,
                                         int fprecision);


    // This utility function will generate parameter definitions using the
    // RenderMan syntax.  By overriding the buildParmCommand() function and
    // simply calling this function, you will get a RenderMan parameter string
    // built.
    int                 buildRenderManParm(UT_WorkBuffer &parm_data,
                                           SHOP_Node *node,
                                           PRM_Template *tplate,
                                           fpreal now,
                                           int fprecision);
};

#endif

---