HOM/HOM_Defines.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
 *      123 Front Street West, Suite 1401
 *      Toronto, Ontario
 *      Canada   M5J 2M2
 *      416-504-9876
 *
 * COMMENTS:
 */

#ifndef __HOM_Defines_h__
#define __HOM_Defines_h__

#include <UT/UT_Assert.h>

// Unfortunately, we can't compare against UT_ASSERT_LEVEL_PARANOID here,
// otherwise the comparison sometimes succeeds under swig when it shouldn't.
// So, we instead compare against the numeric value itself.
#if UT_ASSERT_LEVEL >= 2
#define HOM_DEBUG
#endif

#ifdef SWIG
#define SWIGOUT(x) x
#else
#define SWIGOUT(x)
#endif

#if defined(SWIG) && defined(SWIGPYTHON)
#define SWIGPYTHONOUT(x) x
#else
#define SWIGPYTHONOUT(x)
#endif

#ifdef SWIG

//----------------------------------------------------------------------------

// Since there's no way for a C++ function to have varying return types,
// we need to add special methods and functions that are only known
// to swig.  For python, there's a typemap for PyObject* so that when
// swig encounters a function returning that type it won't try to wrap
// the return value, and will instead send it directly to the interpreter.
// We create a typemap for this type so our code can use it instead of
// PyObject* directly so it's easier to use more than just python in the
// future.

// The swig code we output directly to the swig wrapper below (using %{%})
// uses InterpreterObject, so we need to say what it is.
%{
#ifdef SWIGPYTHON
typedef PyObject *InterpreterObject;
#endif
%}

// We need to tell swig what InterpreterObject is so it applies the PyObject*
// typemap properly.
typedef PyObject *InterpreterObject;

//----------------------------------------------------------------------------

%{
// These helper functions convert from C++ objects to corresponding
// interpreter objects (PyObject*'s in python).  They're roughly the same
// as swig::from(), but swig::from() does a slow lookup on the name of the
// type.  These functions know the type at compile-time so they're faster.
// Unfortunately, we need to explicitly specialize all the types supported by
// the functions.  Specifically, since HOM_IterableList calls these functions,
// objects that can be inside HOM_IterableList need to be specialized below.

// The general case is left unimplemented so we get compiler errors if
// we call the function with an unspecialized type.
template <typename T> InterpreterObject
HOMconvertValueForInterpreter(const T &value, int own);

// These functions specialize the native data types.
template <> InterpreterObject
HOMconvertValueForInterpreter<int>(const int& value, int /*own*/)
{ return SWIG_From_int(value); }

template <> InterpreterObject
HOMconvertValueForInterpreter<float>(const float& value, int /*own*/)
{ return SWIG_From_float(value); }

template <> InterpreterObject
HOMconvertValueForInterpreter<double>(const double& value, int /*own*/)
{ return SWIG_From_double(value); }

template <> InterpreterObject
HOMconvertValueForInterpreter<std::string>(
    const std::string& value, int /*own*/)
{ return SWIG_From_std_string(value); }

// These functions specialize base classes to return interpreter instances
// of the proper subclass.
template <> InterpreterObject
HOMconvertValueForInterpreter<HOM_Node*>(HOM_Node *const &node, int own)
{
    OBJ_OBJECT_TYPE      objtype;
    OP_OpTypeId          optypeid;

    if (!node)
        return SWIG_NewPointerObj(node, SWIGTYPE_p_HOM_Node, own);

    optypeid = (OP_OpTypeId)node->opTypeIdAsInt();
    switch (optypeid)
    {
    case OBJ_OPTYPE_ID:
        // Because of multiple inheritance, it's extremely important that
        // we explicitly cast the pointer to a HOM_ObjNode so we
        // pass the right address to SWIG_NewPointerObject, since it takes
        // a void*.
        objtype = (OBJ_OBJECT_TYPE)node->objTypeAsInt();
        return SWIG_NewPointerObj(
                (void*)dynamic_cast<const HOM_ObjNode* const>(node),
                SWIGTYPE_p_HOM_ObjNode, own);

    case SOP_OPTYPE_ID:
        // Because of multiple inheritance, it's extremely important that
        // we explicitly cast the pointer to a HOM_SopNode so we
        // pass the right address to SWIG_NewPointerObject, since it takes
        // a void*.
        return SWIG_NewPointerObj(
            (void*)dynamic_cast<const HOM_SopNode* const>(node),
            SWIGTYPE_p_HOM_SopNode, own);

    case CHOP_OPTYPE_ID:
        // Because of multiple inheritance, it's extremely important that
        // we explicitly cast the pointer to a HOM_ChopNode so we
        // pass the right address to SWIG_NewPointerObject, since it takes
        // a void*.
        return SWIG_NewPointerObj(
            (void*)dynamic_cast<const HOM_ChopNode* const>(node),
            SWIGTYPE_p_HOM_ChopNode, own);

    case COP2_OPTYPE_ID:
        // Because of multiple inheritance, it's extremely important that
        // we explicitly cast the pointer to a HOM_CopNode so we
        // pass the right address to SWIG_NewPointerObject, since it takes
        // a void*.
        return SWIG_NewPointerObj(
            (void*)dynamic_cast<const HOM_CopNode* const>(node),
            SWIGTYPE_p_HOM_CopNode, own);

    case DOP_OPTYPE_ID:
        // Because of multiple inheritance, it's extremely important that
        // we explicitly cast the pointer to a HOM_DopNode so we
        // pass the right address to SWIG_NewPointerObject, since it takes
        // a void*.
        return SWIG_NewPointerObj(
            (void*)dynamic_cast<const HOM_DopNode* const>(node),
            SWIGTYPE_p_HOM_DopNode, own);

    case POP_OPTYPE_ID:
        // Because of multiple inheritance, it's extremely important that
        // we explicitly cast the pointer to a HOM_PopNode so we
        // pass the right address to SWIG_NewPointerObject, since it takes
        // a void*.
        return SWIG_NewPointerObj(
            (void*)dynamic_cast<const HOM_PopNode* const>(node),
            SWIGTYPE_p_HOM_PopNode, own);

    case POPNET_OPTYPE_ID:
        // Because of multiple inheritance, it's extremely important that
        // we explicitly cast the pointer to a HOM_PopNetNode so we
        // pass the right address to SWIG_NewPointerObject, since it takes
        // a void*.
        return SWIG_NewPointerObj(
            (void*)dynamic_cast<const HOM_PopNetNode* const>(node),
            SWIGTYPE_p_HOM_PopNetNode, own);

    case SHOP_OPTYPE_ID:
        // Because of multiple inheritance, it's extremely important that
        // we explicitly cast the pointer to a HOM_ShopNode so we
        // pass the right address to SWIG_NewPointerObject, since it takes
        // a void*.
        return SWIG_NewPointerObj(
            (void*)dynamic_cast<const HOM_ShopNode* const>(node),
            SWIGTYPE_p_HOM_ShopNode, own);

    case VOPNET_OPTYPE_ID:
        // Because of multiple inheritance, it's extremely important that
        // we explicitly cast the pointer to a HOM_VopNetNode so we
        // pass the right address to SWIG_NewPointerObject, since it takes
        // a void*.
        return SWIG_NewPointerObj(
            (void*)dynamic_cast<const HOM_VopNetNode* const>(node),
            SWIGTYPE_p_HOM_VopNetNode, own);

    case ROP_OPTYPE_ID:
        // Because of multiple inheritance, it's extremely important that
        // we explicitly cast the pointer to a HOM_RopNode so we
        // pass the right address to SWIG_NewPointerObject, since it takes
        // a void*.
        return SWIG_NewPointerObj(
            (void*)dynamic_cast<const HOM_RopNode* const>(node),
            SWIGTYPE_p_HOM_RopNode, own);

    case VOP_OPTYPE_ID:
        // Because of multiple inheritance, it's extremely important that
        // we explicitly cast the pointer to a HOM_VopNode so we
        // pass the right address to SWIG_NewPointerObject, since it takes
        // a void*.
        return SWIG_NewPointerObj(
            (void*)dynamic_cast<const HOM_VopNode* const>(node),
            SWIGTYPE_p_HOM_VopNode, own);

    default:
        break;
    };

    return SWIG_NewPointerObj(node, SWIGTYPE_p_HOM_Node, own);
}

template <> InterpreterObject
HOMconvertValueForInterpreter<HOM_NodeType*>(
    HOM_NodeType *const &nodetype, int own)
{
    OP_OpTypeId          optypeid;
        
    if (!nodetype)
        return SWIG_NewPointerObj(nodetype, SWIGTYPE_p_HOM_NodeType, own);

    if( !nodetype->managerFlag() )
    {
        optypeid = (OP_OpTypeId)nodetype->opTypeIdAsInt();
        switch (optypeid)
        {
        case SOP_OPTYPE_ID:
            // Because of multiple inheritance, it's extremely important that
            // we explicitly cast the pointer to a HOM_SopNodeType so we
            // pass the right address to SWIG_NewPointerObject, since it takes
            // a void*.
            return SWIG_NewPointerObj(
                (void*)dynamic_cast<const HOM_SopNodeType* const>(nodetype),
                SWIGTYPE_p_HOM_SopNodeType, own);

        case SHOP_OPTYPE_ID:
            // Because of multiple inheritance, it's extremely important that
            // we explicitly cast the pointer to a HOM_ShopNodeType so we
            // pass the right address to SWIG_NewPointerObject, since it takes
            // a void*.
            return SWIG_NewPointerObj(
                (void*)dynamic_cast<const HOM_ShopNodeType* const>(nodetype),
                SWIGTYPE_p_HOM_ShopNodeType, own);

        default:
            break;
        }
    }

    return SWIG_NewPointerObj(nodetype, SWIGTYPE_p_HOM_NodeType, own);
}

template <> InterpreterObject
HOMconvertValueForInterpreter<HOM_BaseKeyframe*>(
    HOM_BaseKeyframe *const &keyframe, int own)
{
    if (!keyframe)
        return SWIG_NewPointerObj(keyframe, SWIGTYPE_p_HOM_BaseKeyframe, own);

    if (keyframe->evaluatedType() == HOM_parmData::Float)
    {
        // Because of multiple inheritance, it's extremely important that
        // we explicitly cast the pointer to a HOM_Keyframe so we
        // pass the right address to SWIG_NewPointerObject, since it takes
        // a void*.
        return SWIG_NewPointerObj(
            (void*)dynamic_cast<const HOM_Keyframe* const>(keyframe),
            SWIGTYPE_p_HOM_Keyframe, own);
    };

    return SWIG_NewPointerObj(keyframe, SWIGTYPE_p_HOM_BaseKeyframe, own);
}

template <> InterpreterObject
HOMconvertValueForInterpreter<HOM_Prim*>(HOM_Prim *const &prim, int own)
{
    if (!prim)
        return SWIG_NewPointerObj(prim, SWIGTYPE_p_HOM_Prim, own);

    // Because of multiple inheritance, it's extremely important that
    // we explicitly cast the pointer to the right HOM type so we
    // pass the right address to SWIG_NewPointerObject, since it takes
    // a void*.

    switch (prim->type().id())
    {
    case HOM_primType::Polygon_Id:
        return SWIG_NewPointerObj(
            (void*)dynamic_cast<const HOM_Polygon* const>(prim),
            SWIGTYPE_p_HOM_Polygon, own);

    case HOM_primType::NURBSCurve_Id:
    case HOM_primType::BezierCurve_Id:
        return SWIG_NewPointerObj(
            (void*)dynamic_cast<const HOM_Face* const>(prim),
            SWIGTYPE_p_HOM_Face, own);

    case HOM_primType::Mesh_Id:
    case HOM_primType::NURBSSurface_Id:
    case HOM_primType::BezierSurface_Id:
        return SWIG_NewPointerObj(
            (void*)dynamic_cast<const HOM_Surface* const>(prim),
            SWIGTYPE_p_HOM_Surface, own);

    case HOM_primType::Circle_Id:
    case HOM_primType::Sphere_Id:
    case HOM_primType::Tube_Id:
        return SWIG_NewPointerObj(
            (void*)dynamic_cast<const HOM_Quadric* const>(prim),
            SWIGTYPE_p_HOM_Quadric, own);

    case HOM_primType::Volume_Id:
        return SWIG_NewPointerObj(
            (void*)dynamic_cast<const HOM_Volume* const>(prim),
            SWIGTYPE_p_HOM_Volume, own);

    // TODO: Support more primitive types.
    }

    return SWIG_NewPointerObj(prim, SWIGTYPE_p_HOM_Prim, own);
}

template <> InterpreterObject
HOMconvertValueForInterpreter<HOM_ParmTemplate*>(
    HOM_ParmTemplate *const &parm_template, int own)
{
    if (!parm_template)
        return SWIG_NewPointerObj(
            parm_template, SWIGTYPE_p_HOM_ParmTemplate, own);

    // Because of multiple inheritance, it's extremely important that we
    // explicitly cast to a pointer to the subclass so we pass the right
    // address to SWIG_NewPointerObject, since it takes a void*.
    switch (parm_template->type().id())
    {
    case HOM_parmTemplateType::Int_Id:
        return SWIG_NewPointerObj(
            (void*)dynamic_cast<const HOM_IntParmTemplate* const>(
                parm_template),
            SWIGTYPE_p_HOM_IntParmTemplate, own);

    case HOM_parmTemplateType::Float_Id:
        return SWIG_NewPointerObj(
            (void*)dynamic_cast<const HOM_FloatParmTemplate* const>(
                parm_template),
            SWIGTYPE_p_HOM_FloatParmTemplate, own);

    case HOM_parmTemplateType::String_Id:
        return SWIG_NewPointerObj(
            (void*)dynamic_cast<const HOM_StringParmTemplate* const>(
                parm_template),
            SWIGTYPE_p_HOM_StringParmTemplate, own);

    case HOM_parmTemplateType::Toggle_Id:
        return SWIG_NewPointerObj(
            (void*)dynamic_cast<const HOM_ToggleParmTemplate* const>(
                parm_template),
            SWIGTYPE_p_HOM_ToggleParmTemplate, own);

    case HOM_parmTemplateType::Menu_Id:
        return SWIG_NewPointerObj(
            (void*)dynamic_cast<const HOM_MenuParmTemplate* const>(
                parm_template),
            SWIGTYPE_p_HOM_MenuParmTemplate, own);

    case HOM_parmTemplateType::Button_Id:
        return SWIG_NewPointerObj(
            (void*)dynamic_cast<const HOM_ButtonParmTemplate* const>(
                parm_template),
            SWIGTYPE_p_HOM_ButtonParmTemplate, own);

    case HOM_parmTemplateType::Label_Id:
        return SWIG_NewPointerObj(
            (void*)dynamic_cast<const HOM_LabelParmTemplate* const>(
                parm_template),
            SWIGTYPE_p_HOM_LabelParmTemplate, own);

    case HOM_parmTemplateType::Separator_Id:
        return SWIG_NewPointerObj(
            (void*)dynamic_cast<const HOM_SeparatorParmTemplate* const>(
                parm_template),
            SWIGTYPE_p_HOM_SeparatorParmTemplate, own);

    case HOM_parmTemplateType::FolderSet_Id:
        return SWIG_NewPointerObj(
            (void*)dynamic_cast<const HOM_FolderSetParmTemplate* const>(
                parm_template),
            SWIGTYPE_p_HOM_FolderSetParmTemplate, own);

    case HOM_parmTemplateType::Folder_Id:
        return SWIG_NewPointerObj(
            (void*)dynamic_cast<const HOM_FolderParmTemplate* const>(
                parm_template),
            SWIGTYPE_p_HOM_FolderParmTemplate, own);

    case HOM_parmTemplateType::Ramp_Id:
        return SWIG_NewPointerObj(
            (void*)dynamic_cast<const HOM_RampParmTemplate* const>(
                parm_template),
            SWIGTYPE_p_HOM_RampParmTemplate, own);
    };

    UT_ASSERT(!"Unknown parm template type");
    return SWIG_NewPointerObj(parm_template, SWIGTYPE_p_HOM_ParmTemplate, own);
}

template <> InterpreterObject
HOMconvertValueForInterpreter<HOM_PaneTab*>(
    HOM_PaneTab *const &pane_tab, int own)
{
    if (!pane_tab)
        return SWIG_NewPointerObj(pane_tab, SWIGTYPE_p_HOM_PaneTab, own);

    // Because of multiple inheritance, it's extremely important that
    // we explicitly cast the pointer to the HOM type so we pass the right
    // address to SWIG_NewPointerObject, since it takes a void*.

    switch (pane_tab->type().id())
    {
    case HOM_paneTabType::ContextViewer_Id:
        return SWIG_NewPointerObj(
            (void*)dynamic_cast<const HOM_ContextViewer* const>(pane_tab),
            SWIGTYPE_p_HOM_ContextViewer, own);

    case HOM_paneTabType::SceneViewer_Id:
        return SWIG_NewPointerObj(
            (void*)dynamic_cast<const HOM_SceneViewer* const>(pane_tab),
            SWIGTYPE_p_HOM_SceneViewer, own);

    case HOM_paneTabType::CompositorViewer_Id:
        return SWIG_NewPointerObj(
            (void*)dynamic_cast<const HOM_CompositorViewer* const>(pane_tab),
            SWIGTYPE_p_HOM_CompositorViewer, own);

    case HOM_paneTabType::ParticleViewer_Id:
        return SWIG_NewPointerObj(
            (void*)dynamic_cast<const HOM_ParticleViewer* const>(pane_tab),
            SWIGTYPE_p_HOM_ParticleViewer, own);

    case HOM_paneTabType::NetworkEditor_Id:
        return SWIG_NewPointerObj(
            (void*)dynamic_cast<const HOM_NetworkEditor* const>(pane_tab),
            SWIGTYPE_p_HOM_NetworkEditor, own);
            
    case HOM_paneTabType::HelpBrowser_Id:
        return SWIG_NewPointerObj(
            (void*)dynamic_cast<const HOM_HelpBrowser* const>(pane_tab),
            SWIGTYPE_p_HOM_HelpBrowser, own);

    case HOM_paneTabType::IPRViewer_Id:
        return SWIG_NewPointerObj(
            (void*)dynamic_cast<const HOM_IPRViewer* const>(pane_tab),
            SWIGTYPE_p_HOM_IPRViewer, own);

    case HOM_paneTabType::ChannelViewer_Id:
    case HOM_paneTabType::OutputViewer_Id:
    case HOM_paneTabType::ShaderViewer_Id:
    case HOM_paneTabType::Parm_Id:
    case HOM_paneTabType::DetailsView_Id:
    case HOM_paneTabType::TreeView_Id:
        return SWIG_NewPointerObj(
            (void*)dynamic_cast<const HOM_PathBasedPaneTab* const>(pane_tab),
            SWIGTYPE_p_HOM_PathBasedPaneTab, own);

    case HOM_paneTabType::ChannelEditor_Id:
    case HOM_paneTabType::ChannelList_Id:
    case HOM_paneTabType::Textport_Id:
    case HOM_paneTabType::PythonShell_Id:
    case HOM_paneTabType::HandleList_Id:
    case HOM_paneTabType::BundleList_Id:
    case HOM_paneTabType::TakeList_Id:
    case HOM_paneTabType::ParmSpreadsheet_Id:
    case HOM_paneTabType::LightLinker_Id:
    case HOM_paneTabType::MaterialPalette_Id:
        return SWIG_NewPointerObj(pane_tab, SWIGTYPE_p_HOM_PaneTab, own);
    };

    UT_ASSERT(!"Unknown pane tab type");
    return SWIG_NewPointerObj(pane_tab, SWIGTYPE_p_HOM_PaneTab, own);
}

template <> InterpreterObject
HOMconvertValueForInterpreter<
    std::vector<HOM_ElemPtr<HOM_NodeConnection> >*>(
        std::vector<HOM_ElemPtr<HOM_NodeConnection> > *const &list,
        int own)
{
    return swig::from(*list);
}

template <> InterpreterObject
HOMconvertValueForInterpreter<HOM_DopData*>(HOM_DopData *const &data, int own)
{
    const HOM_DopObject *const dop_object =
        dynamic_cast<const HOM_DopObject *const>(data);
    if (dop_object)
        return SWIG_NewPointerObj(
            (void *)dop_object, SWIGTYPE_p_HOM_DopObject, own);

    const HOM_DopRelationship *const dop_relationship =
        dynamic_cast<const HOM_DopRelationship *const>(data);
    if (dop_relationship)
        return SWIG_NewPointerObj(
            (void *)dop_relationship, SWIGTYPE_p_HOM_DopRelationship, own);

    return SWIG_NewPointerObj(data, SWIGTYPE_p_HOM_DopData, own);
}

// These functions specialize pointers to other classes.  If a class is
// used inside HOM_IterableList or HOM_ElemPtr, it must be listed here.
#define HOM_PROVIDE_SWIG_LOOKUP(type) \
    template <> InterpreterObject HOMconvertValueForInterpreter<type*>( \
        type* const& value, int own) \
    { return SWIG_NewPointerObj(SWIG_as_voidptr(value), \
            SWIGTYPE_p_ ## type, own); }

HOM_PROVIDE_SWIG_LOOKUP(HOM_Attrib)
HOM_PROVIDE_SWIG_LOOKUP(HOM_Desktop)
HOM_PROVIDE_SWIG_LOOKUP(HOM_Dialog)
HOM_PROVIDE_SWIG_LOOKUP(HOM_DopRecord)
HOM_PROVIDE_SWIG_LOOKUP(HOM_FloatingPanel)
HOM_PROVIDE_SWIG_LOOKUP(HOM_Gallery)
HOM_PROVIDE_SWIG_LOOKUP(HOM_GalleryEntry)
HOM_PROVIDE_SWIG_LOOKUP(HOM_GeometrySelection)
HOM_PROVIDE_SWIG_LOOKUP(HOM_GeometryViewport)
HOM_PROVIDE_SWIG_LOOKUP(HOM_HDADefinition)
HOM_PROVIDE_SWIG_LOOKUP(HOM_HDASection)
HOM_PROVIDE_SWIG_LOOKUP(HOM_Matrix3)
HOM_PROVIDE_SWIG_LOOKUP(HOM_Matrix4)
HOM_PROVIDE_SWIG_LOOKUP(HOM_NetworkBox)
HOM_PROVIDE_SWIG_LOOKUP(HOM_NodeBundle)
HOM_PROVIDE_SWIG_LOOKUP(HOM_NodeConnection)
HOM_PROVIDE_SWIG_LOOKUP(HOM_NodeGroup)
HOM_PROVIDE_SWIG_LOOKUP(HOM_Pane)
HOM_PROVIDE_SWIG_LOOKUP(HOM_Parm)
HOM_PROVIDE_SWIG_LOOKUP(HOM_ParmTuple)
HOM_PROVIDE_SWIG_LOOKUP(HOM_Point)
HOM_PROVIDE_SWIG_LOOKUP(HOM_PointGroup)
HOM_PROVIDE_SWIG_LOOKUP(HOM_PrimGroup)
HOM_PROVIDE_SWIG_LOOKUP(HOM_Quaternion)
HOM_PROVIDE_SWIG_LOOKUP(HOM_Ramp)
HOM_PROVIDE_SWIG_LOOKUP(HOM_Selector)
HOM_PROVIDE_SWIG_LOOKUP(HOM_Shelf)
HOM_PROVIDE_SWIG_LOOKUP(HOM_ShelfSet)
HOM_PROVIDE_SWIG_LOOKUP(HOM_StickyNote)
HOM_PROVIDE_SWIG_LOOKUP(HOM_SubnetIndirectInput)
HOM_PROVIDE_SWIG_LOOKUP(HOM_Tool)
HOM_PROVIDE_SWIG_LOOKUP(HOM_Track)
HOM_PROVIDE_SWIG_LOOKUP(HOM_Vector2)
HOM_PROVIDE_SWIG_LOOKUP(HOM_Vector3)
HOM_PROVIDE_SWIG_LOOKUP(HOM_Vector4)
HOM_PROVIDE_SWIG_LOOKUP(HOM_Vertex)
HOM_PROVIDE_SWIG_LOOKUP(HOM_VexContext)
HOM_PROVIDE_SWIG_LOOKUP(HOM_ViewerState)

%}

//----------------------------------------------------------------------------

// We create typemaps for base classes that appear as return types to make
// sure swig instances the proper subclasses in the interpreter.
%typemap(out) HOM_Prim* {
    $result = HOMconvertValueForInterpreter($1, $owner);
}

%typemap(out) HOM_Node* {
    $result = HOMconvertValueForInterpreter($1, $owner);
}

%typemap(out) HOM_NodeType* {
    $result = HOMconvertValueForInterpreter($1, $owner);
}

%typemap(out) HOM_BaseKeyframe* {
    $result = HOMconvertValueForInterpreter($1, $owner);
}

%typemap(out) HOM_ParmTemplate* {
    $result = HOMconvertValueForInterpreter($1, $owner);
}

%typemap(out) HOM_Pane* {
    $result = HOMconvertValueForInterpreter($1, $owner);
}

%typemap(out) HOM_PaneTab* {
    $result = HOMconvertValueForInterpreter($1, $owner);
}

%typemap(out) HOM_DopData* {
    $result = HOMconvertValueForInterpreter($1, $owner);
}

%typemap(out) std::vector<HOM_ElemPtr<HOM_NodeConnection> > * {
    $result = HOMconvertValueForInterpreter($1, $owner);
}

//----------------------------------------------------------------------------

// These typemaps convert HOM exceptions into corresponding python standard
// exceptions.
%typemap(throws) HOM_TypeError %{
    SWIG_exception_fail(SWIG_TypeError, $1.instanceMessage().c_str());
%}

%typemap(throws) HOM_ValueError %{
    SWIG_exception_fail(SWIG_ValueError, $1.instanceMessage().c_str());
%}

#ifdef SWIGPYTHON
%typemap(throws) HOM_SystemExit %{
    PyErr_SetObject(PyExc_SystemExit, SWIG_From_int($1.code()));
    SWIG_fail;
%}
#endif

//----------------------------------------------------------------------------

// This typemap lets you declare a boost::any parameter and swig will convert
// the interpreter (Python) object to a boost::any that wraps the C++ data
// type.
%typemap(in) boost::any {
    // Note that if we can't convert to a boost::any, we leave the boost::any
    // as empty (i.e. its empty() method returns true).
    HOMinterpreterObjectToBoostAny($input, $1);
}

// This typemap lets you return boost::any objects.
%typemap(out) boost::any {
    $result = HOMboostAnyToInterpreterObject($1);
}

%{

//----------------------------------------------------------------------------

// This helper function takes an interpreter (Python) object and converts it
// into a boost::any object.  It returns whether or not the conversion was
// possible, and leaves the boost::any unchanged if a conversion wasn't
// possible.
bool
HOMinterpreterObjectToBoostAny(InterpreterObject input, boost::any &result)
{
#ifdef SWIGPYTHON
    if (input == Py_None)
    {
        result = (void *)NULL;
        return true;
    }

    // SWIG_AsVal_bool is too permissive, and treats thinks that an integer
    // is a bool.  So, we explicitly check against True and False.
    if (input == Py_True)
    {
        result = true;
        return true;
    }

    if (input == Py_False)
    {
        result = false;
        return true;
    }
#endif

    int int_result;
    if (SWIG_IsOK(SWIG_AsVal_int(input, &int_result)))
    {
        result = int_result;
        return true;
    }

    double double_result;
    if (SWIG_IsOK(SWIG_AsVal_double(input, &double_result)))
    {
        result = double_result;
        return true;
    }

    std::string string_result;
    if (SWIG_IsOK(SWIG_AsVal_std_string(input, &string_result)))
    {
        result = string_result;
        return true;
    }

    std::vector<int> *int_vector_ptr = NULL;
    if (SWIG_IsOK(swig::asptr(input, (std::vector<int> **)NULL)) &&
        SWIG_IsOK(swig::asptr(input, &int_vector_ptr)))
    {
        result = *int_vector_ptr;
        delete int_vector_ptr;
        return true;
    }

    std::vector<double> *double_vector_ptr = NULL;
    if (SWIG_IsOK(swig::asptr(input, (std::vector<double> **)NULL)) &&
        SWIG_IsOK(swig::asptr(input, &double_vector_ptr)))
    {
        result = *double_vector_ptr;
        delete double_vector_ptr;
        return true;
    }

    std::vector<std::string> *string_vector_ptr = NULL;
    if (SWIG_IsOK(swig::asptr(input, (std::vector<std::string> **)NULL)) &&
        SWIG_IsOK(swig::asptr(input, &string_vector_ptr)))
    {
        result = *string_vector_ptr;
        delete string_vector_ptr;
        return true;
    }

    std::vector<HOM_Vector3> *vector3_vector_ptr = NULL;
    if (SWIG_IsOK(swig::asptr(input, (std::vector<HOM_Vector3> **)NULL)) &&
        SWIG_IsOK(swig::asptr(input, &vector3_vector_ptr)))
    {
        result = *vector3_vector_ptr;
        delete vector3_vector_ptr;
        return true;
    }

    std::vector<HOM_Vector4> *vector4_vector_ptr = NULL;
    if (SWIG_IsOK(swig::asptr(input, (std::vector<HOM_Vector4> **)NULL)) &&
        SWIG_IsOK(swig::asptr(input, &vector4_vector_ptr)))
    {
        result = *vector4_vector_ptr;
        delete vector4_vector_ptr;
        return true;
    }

    std::vector<HOM_Matrix3> *matrix3_vector_ptr = NULL;
    if (SWIG_IsOK(swig::asptr(input, (std::vector<HOM_Matrix3> **)NULL)) &&
        SWIG_IsOK(swig::asptr(input, &matrix3_vector_ptr)))
    {
        result = *matrix3_vector_ptr;
        delete matrix3_vector_ptr;
        return true;
    }

    std::vector<HOM_Matrix4> *matrix4_vector_ptr = NULL;
    if (SWIG_IsOK(swig::asptr(input, (std::vector<HOM_Matrix4> **)NULL)) &&
        SWIG_IsOK(swig::asptr(input, &matrix4_vector_ptr)))
    {
        result = *matrix4_vector_ptr;
        delete matrix4_vector_ptr;
        return true;
    }

    UT_ASSERT(result.empty());
    return false;
}

// Creating an input typemap isn't sufficient to handle input parameters with
// std::vector's or std::map's of boost::any's, so we need to specialize
// swig::traits_asptr<boost::any>.
namespace swig {
    template <>
    struct traits_asptr<boost::any>
    {
        static int asptr(InterpreterObject obj, boost::any **val)
        {
            // TODO: Will the boost::any be properly deleted?
            boost::any *p = new boost::any();
            HOMinterpreterObjectToBoostAny(obj, *p);
            if (val)
                *val = p;
            return SWIG_NEWOBJ;
        }
    };
}

// This helper function takes a variable wrapped inside a boost::any object
// and creates a new instance of the corresponding InterpreterObject.
static InterpreterObject
HOMboostAnyToInterpreterObject(const boost::any &result)
{
    if (result.empty())
        return SWIG_Py_Void();

    if (result.type() == typeid(int))
        return SWIG_From_int(boost::any_cast<int>(result));

    if (result.type() == typeid(float))
        return SWIG_From_float(boost::any_cast<float>(result));

    if (result.type() == typeid(double))
        return SWIG_From_double(boost::any_cast<double>(result));

    if (result.type() == typeid(std::string))
        return SWIG_From_std_string(boost::any_cast<std::string>(result));

    if (result.type() == typeid(std::vector<int>))
        return swig::from(boost::any_cast<std::vector<int> >(result));

    if (result.type() == typeid(std::vector<float>))
        return swig::from(boost::any_cast<std::vector<float> >(result));

    if (result.type() == typeid(std::vector<std::string>))
        return swig::from(boost::any_cast<std::vector<std::string> >(result));

    if (result.type() == typeid(std::vector<double>))
        return swig::from(boost::any_cast<std::vector<double> >(result));

    if (result.type() == typeid(std::vector<std::vector<float> >))
        return swig::from(
            boost::any_cast<std::vector<std::vector<float> > >(result));

    if (result.type() == typeid(std::vector<std::vector<double> >))
        return swig::from(
            boost::any_cast<std::vector<std::vector<double> > >(result));

    // If a HOM function returns a pointer to a HOM_Vector*/HOM_Matrix*, it
    // will transfer the ownership of that object to swig.
    if (result.type() == typeid(HOM_Vector3 *))
        return HOMconvertValueForInterpreter(
                boost::any_cast<HOM_Vector3 *>(result), SWIG_POINTER_OWN);

    if (result.type() == typeid(HOM_Vector4 *))
        return HOMconvertValueForInterpreter(
                boost::any_cast<HOM_Vector4 *>(result), SWIG_POINTER_OWN);

    if (result.type() == typeid(HOM_Matrix3 *))
        return HOMconvertValueForInterpreter(
                boost::any_cast<HOM_Matrix3 *>(result), SWIG_POINTER_OWN);

    if (result.type() == typeid(HOM_Matrix4 *))
        return HOMconvertValueForInterpreter(
                boost::any_cast<HOM_Matrix4 *>(result), SWIG_POINTER_OWN);

    if (result.type() == typeid(std::vector<HOM_ElemPtr<HOM_Vector3> >))
        return swig::from(
            boost::any_cast<std::vector<HOM_ElemPtr<HOM_Vector3> > >(result));

    if (result.type() == typeid(std::vector<HOM_ElemPtr<HOM_Vector4> >))
        return swig::from(
            boost::any_cast<std::vector<HOM_ElemPtr<HOM_Vector4> > >(result));

    if (result.type() == typeid(std::vector<HOM_ElemPtr<HOM_Matrix3> >))
        return swig::from(
            boost::any_cast<std::vector<HOM_ElemPtr<HOM_Matrix3> > >(result));

    if (result.type() == typeid(std::vector<HOM_ElemPtr<HOM_Matrix4> >))
        return swig::from(
            boost::any_cast<std::vector<HOM_ElemPtr<HOM_Matrix4> > >(result));

#if UT_ASSERT_LEVEL > 0
    cout << "Unknown data type: "
         << UTunmangleClassNameFromTypeIdName(result.type().name()) << endl;
#endif
    UT_ASSERT(!"Unknown data type");
    return SWIG_Py_Void();
}

namespace swig {
    // Adding the typemap does not customize swig::from() so we do that
    // manually.
    template <>
    struct traits_from<boost::any>
    {
        static PyObject *from(const boost::any &val)
        { return HOMboostAnyToInterpreterObject(val); }
    };
}

static InterpreterObject
HOMoptionEntryToInterpreterObject(const UT_OptionEntry &option_entry)
{
    InterpreterObject result = NULL;

    switch (option_entry.getType())
    {
        case UT_OPTION_INT:
            return SWIG_From_int(
                ((const UT_OptionInt &)option_entry).getValue());

        case UT_OPTION_BOOL:
            return SWIG_From_bool(
                ((const UT_OptionBool &)option_entry).getValue());

        case UT_OPTION_FPREAL:
            return SWIG_From_double(
                ((const UT_OptionFpreal &)option_entry).getValue());

        case UT_OPTION_STRING:
        case UT_OPTION_STRINGRAW:
            return SWIG_From_std_string(
                 ((const UT_OptionString &)option_entry).getValue());

        case UT_OPTION_VECTOR2:
            return HOMconvertValueForInterpreter(
                 new HOM_Vector2(
                     ((const UT_OptionVector2 &)option_entry).getValue()),
                 SWIG_POINTER_OWN);

        case UT_OPTION_VECTOR3:
            return HOMconvertValueForInterpreter(
                 new HOM_Vector3(
                    ((const UT_OptionVector3 &)option_entry).getValue()),
                 SWIG_POINTER_OWN);

        case UT_OPTION_VECTOR4:
            return HOMconvertValueForInterpreter(
                 new HOM_Vector4(
                    ((const UT_OptionVector4 &)option_entry).getValue()),
                 SWIG_POINTER_OWN);

        case UT_OPTION_QUATERNION:
            return HOMconvertValueForInterpreter(
                 new HOM_Quaternion(
                     ((const UT_OptionQuaternion &)option_entry).getValue()),
                 SWIG_POINTER_OWN);

        case UT_OPTION_MATRIX3:
            return HOMconvertValueForInterpreter(
                 new HOM_Matrix3(UT_DMatrix3(
                    ((const UT_OptionMatrix3 &)option_entry).getValue())),
                 SWIG_POINTER_OWN);

        case UT_OPTION_MATRIX4:
            return HOMconvertValueForInterpreter(
                 new HOM_Matrix4(UT_DMatrix4(
                    ((const UT_OptionMatrix4 &)option_entry).getValue())),
                 SWIG_POINTER_OWN);

        case UT_OPTION_UV:
            return HOMconvertValueForInterpreter(
                 new HOM_Vector2(
                    ((const UT_OptionUV &)option_entry).getValue()),
                 SWIG_POINTER_OWN);

        case UT_OPTION_UVW:
            return HOMconvertValueForInterpreter(
                 new HOM_Vector3(
                     ((const UT_OptionUVW &)option_entry).getValue()),
                 SWIG_POINTER_OWN);

        case UT_OPTION_INVALID:
        case UT_OPTION_NUM_TYPES:
            // Just exit the switch with no result.
            break;
    }

    return result ? result : SWIG_Py_Void();
}

#ifdef SWIGPYTHON
static InterpreterObject
HOMoptionsToInterpreterObject(UT_Options &options)
{
    InterpreterObject result = PyDict_New();

    for (int i=0; i < options.getNumOptions(); ++i)
    {
        // The Python dictionary object will increment the reference count
        // on the value, so we decrement it since we just allocated it.
        InterpreterObject value = HOMoptionEntryToInterpreterObject(
            *options.getOptionEntry(i));
        PyDict_SetItemString(result, options.getOptionName(i), value);
        Py_DECREF(value);
    }

    return result;
}
#endif

//----------------------------------------------------------------------------

// These helper functions are used to implement the attrib() methods of
// Points, Prims, and Vertices.  We need to do extra work for these methods
// because the return type can vary.
template <typename T>
InterpreterObject
HOMattribValue(T &geo_element, HOM_Attrib &hom_attrib)
    throw(HOM_OperationFailed, HOM_ObjectWasDeleted, HOM_Error)
{
    InterpreterObject result = NULL;
    switch (hom_attrib.dataType().id())
    {
    case HOM_attribData::Int_Id:
        if (hom_attrib.size() == 1)
            result = SWIG_From_int(geo_element.intAttribValue(hom_attrib));
        else
            result = swig::from(geo_element.intListAttribValue(hom_attrib));
        break;

    case HOM_attribData::Float_Id:
        if (hom_attrib.size() == 1)
            result = SWIG_From_double(geo_element.floatAttribValue(hom_attrib));
        else
            result = swig::from(geo_element.floatListAttribValue(hom_attrib));
        break;

    case HOM_attribData::String_Id:
        if (hom_attrib.size() == 1)
            result = SWIG_From_std_string(
                geo_element.stringAttribValue(hom_attrib));
        else
            result = swig::from(geo_element.stringListAttribValue(hom_attrib));
        break;
    }
    UT_ASSERT(result);
    return result;
}


// Note that the caller is responsible for deleting the HOM_Attrib object
// that's returned.
template <typename T> HOM_Attrib*
HOMlookUpAttrib(T &geo_element, const char *name)
    throw(HOM_ObjectWasDeleted, HOM_Error);

template <> HOM_Attrib*
HOMlookUpAttrib(HOM_Point &point, const char *name)
    throw(HOM_ObjectWasDeleted, HOM_Error)
{ return HOMdel(point.geometry())->findPointAttrib(name); }

template <> HOM_Attrib*
HOMlookUpAttrib(HOM_Prim &prim, const char *name)
    throw(HOM_ObjectWasDeleted, HOM_Error)
{ return HOMdel(prim.geometry())->findPrimAttrib(name); }

template <> HOM_Attrib*
HOMlookUpAttrib(HOM_Vertex &vertex, const char *name)
    throw(HOM_ObjectWasDeleted, HOM_Error)
{ return HOMdel(vertex.geometry())->findVertexAttrib(name); }

template <> HOM_Attrib*
HOMlookUpAttrib(HOM_Geometry &geometry, const char *name)
    throw(HOM_ObjectWasDeleted, HOM_Error)
{ return geometry.findGlobalAttrib(name); }

template <typename T>
InterpreterObject
HOMattribValue(T &geo_element, const char *name)
    throw(HOM_OperationFailed, HOM_ObjectWasDeleted, HOM_Error)
{
    HOM_Attrib *hom_attrib = HOMlookUpAttrib(geo_element, name);
    if (!hom_attrib)
        throw HOM_OperationFailed();

    InterpreterObject result = HOMattribValue(geo_element, *hom_attrib);
    delete hom_attrib;
    return result;
}
%}

//----------------------------------------------------------------------------

%{
// These helper functions are used to implement parm evaluation.
static InterpreterObject
HOMevalParm(HOM_Parm &parm) throw(HOM_ObjectWasDeleted, HOM_Error)
{
    switch (parm.parmDataTypeEnumId())
    {
    case HOM_parmData::Int_Id:
        return SWIG_From_int(parm.evalAsInt());
    case HOM_parmData::Float_Id:
        return SWIG_From_double(parm.evalAsFloat());
    case HOM_parmData::String_Id:
        return SWIG_From_std_string(parm.evalAsString());
    case HOM_parmData::Ramp_Id:
        return SWIG_NewPointerObj(
            (void*)parm.evalAsRamp(), SWIGTYPE_p_HOM_Ramp, SWIG_POINTER_OWN);
    }

    UT_ASSERT(!"Unknown parm data type");
    return SWIG_Py_Void();
}

static InterpreterObject
HOMevalParmAtFrame(HOM_Parm &parm, double frame)
    throw(HOM_ObjectWasDeleted, HOM_Error)
{
    switch (parm.parmDataTypeEnumId())
    {
    case HOM_parmData::Int_Id:
        return SWIG_From_int(parm.evalAsIntAtFrame(frame));
    case HOM_parmData::Float_Id:
        return SWIG_From_double(parm.evalAsFloatAtFrame(frame));
    case HOM_parmData::String_Id:
        return SWIG_From_std_string(parm.evalAsStringAtFrame(frame));
    case HOM_parmData::Ramp_Id:
        return SWIG_NewPointerObj(
            (void*)parm.evalAsRampAtFrame(frame),
            SWIGTYPE_p_HOM_Ramp, SWIG_POINTER_OWN);
    }

    UT_ASSERT(!"Unknown parm data type");
    return SWIG_Py_Void();
}

static InterpreterObject
HOMevalParmTuple(HOM_ParmTuple &parm_tuple)
    throw(HOM_ObjectWasDeleted, HOM_Error)
{
    switch (parm_tuple.parmDataTypeEnumId())
    {
    case HOM_parmData::Int_Id:
        return swig::from(parm_tuple.evalAsInts());
    case HOM_parmData::Float_Id:
        return swig::from(parm_tuple.evalAsFloats());
    case HOM_parmData::String_Id:
        return swig::from(parm_tuple.evalAsStrings());
    case HOM_parmData::Ramp_Id:
        return swig::from(parm_tuple.evalAsRamps());
    }

    UT_ASSERT(!"Unknown parm data type");
    return SWIG_Py_Void();
}

static InterpreterObject
HOMevalParmTupleAtFrame(HOM_ParmTuple &parm_tuple, double frame)
    throw(HOM_ObjectWasDeleted, HOM_Error)
{
    switch (parm_tuple.parmDataTypeEnumId())
    {
    case HOM_parmData::Int_Id:
        return swig::from(parm_tuple.evalAsIntsAtFrame(frame));
    case HOM_parmData::Float_Id:
        return swig::from(parm_tuple.evalAsFloatsAtFrame(frame));
    case HOM_parmData::String_Id:
        return swig::from(parm_tuple.evalAsStringsAtFrame(frame));
    case HOM_parmData::Ramp_Id:
        return swig::from(parm_tuple.evalAsRampsAtFrame(frame));
    }

    UT_ASSERT(!"Unknown parm data type");
    return SWIG_Py_Void();
}

//----------------------------------------------------------------------------

%}
#endif

#endif

---