9 #ifndef __HOM_Defines_h__
10 #define __HOM_Defines_h__
17 #if UT_ASSERT_LEVEL >= 2
27 #if defined(SWIG) && defined(SWIGPYTHON)
28 #define SWIGPYTHONOUT(x) x
30 #define SWIGPYTHONOUT(x)
36 #include <hboost/any.hpp>
50 #define HOM_MIN_NEGATIVE_DOUBLE -1 * std::numeric_limits<double>::max()
69 typedef PyObject *InterpreterObject;
71 PyObject *HOMincRef(PyObject *
object)
83 typedef PyObject *InterpreterObject;
102 template <
typename T> InterpreterObject
103 HOMconvertValueForInterpreter(
const T &
value,
int own);
106 template <> InterpreterObject
107 HOMconvertValueForInterpreter<int>(
const int&
value,
int )
108 {
return SWIG_From_int(value); }
110 template <> InterpreterObject
111 HOMconvertValueForInterpreter<float>(
const float&
value,
int )
112 {
return SWIG_From_float(value); }
114 template <> InterpreterObject
115 HOMconvertValueForInterpreter<double>(
const double&
value,
int )
116 {
return SWIG_From_double(value); }
118 template <> InterpreterObject
119 HOMconvertValueForInterpreter<std::string>(
121 {
return SWIG_From_std_string(value); }
125 template <> InterpreterObject
126 HOMconvertValueForInterpreter<HOM_Node*>(
HOM_Node *
const &node,
int own)
132 bool isnetwork =
false;
134 if (!node || (!opnode && !apexnode))
135 return SWIG_NewPointerObj(node, SWIGTYPE_p_HOM_Node, own);
138 return SWIG_NewPointerObj(node, SWIGTYPE_p_HOM_ApexNode, own);
148 return SWIG_NewPointerObj(
149 (
void*)dynamic_cast<HOM_ObjNode* const>(node),
150 SWIGTYPE_p_HOM_ObjNode, own);
157 return SWIG_NewPointerObj(
158 (
void*)dynamic_cast<HOM_SopNode* const>(node),
159 SWIGTYPE_p_HOM_SopNode, own);
166 return SWIG_NewPointerObj(
167 (
void*)dynamic_cast<HOM_ChopNode* const>(node),
168 SWIGTYPE_p_HOM_ChopNode, own);
175 return SWIG_NewPointerObj(
176 (
void*)dynamic_cast<HOM_Cop2Node* const>(node),
177 SWIGTYPE_p_HOM_Cop2Node, own);
184 return SWIG_NewPointerObj(
185 (
void*)dynamic_cast<HOM_DopNode* const>(node),
186 SWIGTYPE_p_HOM_DopNode, own);
193 return SWIG_NewPointerObj(
194 (
void*)dynamic_cast<HOM_ShopNode* const>(node),
195 SWIGTYPE_p_HOM_ShopNode, own);
202 return SWIG_NewPointerObj(
203 (
void*)dynamic_cast<HOM_VopNetNode* const>(node),
204 SWIGTYPE_p_HOM_VopNetNode, own);
211 return SWIG_NewPointerObj(
212 (
void*)dynamic_cast<HOM_RopNode* const>(node),
213 SWIGTYPE_p_HOM_RopNode, own);
220 return SWIG_NewPointerObj(
221 (
void*)dynamic_cast<HOM_VopNode* const>(node),
222 SWIGTYPE_p_HOM_VopNode, own);
229 return SWIG_NewPointerObj(
230 (
void*)dynamic_cast<HOM_TopNode* const>(node),
231 SWIGTYPE_p_HOM_TopNode, own);
241 nodetype = node->type();
242 isnetwork = (nodetype && nodetype->
isManager(
true));
245 return SWIG_NewPointerObj(
246 (
void*)dynamic_cast<HOM_LopNetwork* const>(node),
247 SWIGTYPE_p_HOM_LopNetwork, own);
249 return SWIG_NewPointerObj(
250 (
void*)dynamic_cast<HOM_LopNode* const>(node),
251 SWIGTYPE_p_HOM_LopNode, own);
261 if (
HOM().lopNodeTypeCategory() == node->childTypeCategory())
262 return SWIG_NewPointerObj(
264 SWIGTYPE_p_HOM_LopNetwork, own);
270 return SWIG_NewPointerObj(opnode, SWIGTYPE_p_HOM_OpNode, own);
273 template <> InterpreterObject
274 HOMconvertValueForInterpreter<HOM_NodeType*>(
281 if (!nodetype || (!opnodetype && !apexnodetype))
282 return SWIG_NewPointerObj(nodetype, SWIGTYPE_p_HOM_NodeType, own);
285 return SWIG_NewPointerObj(nodetype, SWIGTYPE_p_HOM_ApexNodeType, own);
287 if( !nodetype->isManager() )
297 return SWIG_NewPointerObj(
298 (
void*)dynamic_cast<const HOM_SopNodeType* const>(nodetype),
299 SWIGTYPE_p_HOM_SopNodeType, own);
306 return SWIG_NewPointerObj(
307 (
void*)dynamic_cast<const HOM_ShopNodeType* const>(nodetype),
308 SWIGTYPE_p_HOM_ShopNodeType, own);
315 return SWIG_NewPointerObj(
316 (
void*)dynamic_cast<const HOM_VopNodeType* const>(nodetype),
317 SWIGTYPE_p_HOM_VopNodeType, own);
323 return SWIG_NewPointerObj(nodetype, SWIGTYPE_p_HOM_OpNodeType, own);
326 template <> InterpreterObject
327 HOMconvertValueForInterpreter<HOM_NodeTypeCategory*>(
335 if (!nodetypecategory || (!opnodetypecategory && !apexnodetypecategory))
336 return SWIG_NewPointerObj(nodetypecategory,
337 SWIGTYPE_p_HOM_NodeTypeCategory, own);
339 if (apexnodetypecategory)
340 return SWIG_NewPointerObj(nodetypecategory,
341 SWIGTYPE_p_HOM_ApexNodeTypeCategory, own);
343 return SWIG_NewPointerObj(nodetypecategory,
344 SWIGTYPE_p_HOM_OpNodeTypeCategory, own);
347 template <> InterpreterObject
348 HOMconvertValueForInterpreter<HOM_NodeTypeCategory&>(
356 if (!opnodetypecategory && !apexnodetypecategory)
357 return SWIG_NewPointerObj(&nodetypecategory,
358 SWIGTYPE_p_HOM_NodeTypeCategory, own);
360 if (apexnodetypecategory)
361 return SWIG_NewPointerObj(&nodetypecategory,
362 SWIGTYPE_p_HOM_ApexNodeTypeCategory, own);
364 return SWIG_NewPointerObj(&nodetypecategory,
365 SWIGTYPE_p_HOM_OpNodeTypeCategory, own);
381 result = HOMconvertValueForInterpreter(val, 0);
397 template <> InterpreterObject
398 HOMconvertValueForInterpreter<HOM_NetworkBox*>(
404 return SWIG_NewPointerObj(obj, SWIGTYPE_p_HOM_NetworkBox, own);
406 return SWIG_NewPointerObj(obj, SWIGTYPE_p_HOM_OpNetworkBox, own);
409 template <> InterpreterObject
410 HOMconvertValueForInterpreter<HOM_NetworkDot*>(
416 return SWIG_NewPointerObj(obj, SWIGTYPE_p_HOM_NetworkDot, own);
418 return SWIG_NewPointerObj(obj, SWIGTYPE_p_HOM_OpNetworkDot, own);
421 template <> InterpreterObject
422 HOMconvertValueForInterpreter<HOM_NodeConnection*>(
428 if (!obj || (!opobj && !apexobj))
429 return SWIG_NewPointerObj(obj, SWIGTYPE_p_HOM_NodeConnection, own);
432 return SWIG_NewPointerObj(obj, SWIGTYPE_p_HOM_ApexNodeConnection, own);
434 return SWIG_NewPointerObj(obj, SWIGTYPE_p_HOM_OpNodeConnection, own);
437 template <> InterpreterObject
438 HOMconvertValueForInterpreter<HOM_StickyNote*>(
444 if (!obj || (!opobj && !apexobj))
445 return SWIG_NewPointerObj(obj, SWIGTYPE_p_HOM_StickyNote, own);
448 return SWIG_NewPointerObj(obj, SWIGTYPE_p_HOM_ApexStickyNote, own);
450 return SWIG_NewPointerObj(obj, SWIGTYPE_p_HOM_OpStickyNote, own);
453 template <> InterpreterObject
454 HOMconvertValueForInterpreter<HOM_SubnetIndirectInput*>(
460 return SWIG_NewPointerObj(obj, SWIGTYPE_p_HOM_SubnetIndirectInput, own);
462 return SWIG_NewPointerObj(obj, SWIGTYPE_p_HOM_OpSubnetIndirectInput, own);
465 template <> InterpreterObject
466 HOMconvertValueForInterpreter<HOM_BaseKeyframe*>(
470 return SWIG_NewPointerObj(keyframe, SWIGTYPE_p_HOM_BaseKeyframe, own);
472 if (keyframe->evaluatedType() == HOM_parmData::Float)
478 return SWIG_NewPointerObj(
479 (
void*)dynamic_cast<const HOM_Keyframe* const>(keyframe),
480 SWIGTYPE_p_HOM_Keyframe, own);
482 else if (keyframe->evaluatedType() == HOM_parmData::String)
488 return SWIG_NewPointerObj(
489 (
void*)dynamic_cast<const HOM_StringKeyframe* const>(keyframe),
490 SWIGTYPE_p_HOM_StringKeyframe, own);
493 return SWIG_NewPointerObj(keyframe, SWIGTYPE_p_HOM_BaseKeyframe, own);
496 template <> InterpreterObject
497 HOMconvertValueForInterpreter<HOM_PackedPrim*>(
HOM_PackedPrim *
const &prim,
int own)
500 return SWIG_NewPointerObj(prim, SWIGTYPE_p_HOM_PackedPrim, own);
507 switch (prim->type().id())
509 case HOM_primType::Agent_Id:
510 return SWIG_NewPointerObj(
511 (
void *)dynamic_cast<HOM_Agent *const>(prim),
512 SWIGTYPE_p_HOM_Agent, own);
514 case HOM_primType::PackedFragment_Id:
515 return SWIG_NewPointerObj(
516 (
void *)dynamic_cast<HOM_PackedFragment *const>(prim),
517 SWIGTYPE_p_HOM_PackedFragment, own);
519 case HOM_primType::PackedGeometry_Id:
520 return SWIG_NewPointerObj(
521 (
void *)dynamic_cast<HOM_PackedGeometry *const>(prim),
522 SWIGTYPE_p_HOM_PackedGeometry, own);
526 return SWIG_NewPointerObj((
void *)prim, SWIGTYPE_p_HOM_PackedPrim, own);
529 template <> InterpreterObject
530 HOMconvertValueForInterpreter<HOM_Prim*>(
HOM_Prim *
const &prim,
int own)
533 return SWIG_NewPointerObj(prim, SWIGTYPE_p_HOM_Prim, own);
541 return HOMconvertValueForInterpreter(packed, own);
543 switch (prim->type().id())
545 case HOM_primType::Polygon_Id:
546 return SWIG_NewPointerObj(
547 (
void*)dynamic_cast<const HOM_Polygon* const>(prim),
548 SWIGTYPE_p_HOM_Polygon, own);
550 case HOM_primType::NURBSCurve_Id:
551 case HOM_primType::BezierCurve_Id:
552 return SWIG_NewPointerObj(
553 (
void*)dynamic_cast<const HOM_Face* const>(prim),
554 SWIGTYPE_p_HOM_Face, own);
556 case HOM_primType::Mesh_Id:
557 case HOM_primType::NURBSSurface_Id:
558 case HOM_primType::BezierSurface_Id:
559 return SWIG_NewPointerObj(
560 (
void*)dynamic_cast<const HOM_Surface* const>(prim),
561 SWIGTYPE_p_HOM_Surface, own);
563 case HOM_primType::Circle_Id:
564 case HOM_primType::Sphere_Id:
565 case HOM_primType::Tube_Id:
566 return SWIG_NewPointerObj(
567 (
void*)dynamic_cast<const HOM_Quadric* const>(prim),
568 SWIGTYPE_p_HOM_Quadric, own);
570 case HOM_primType::Volume_Id:
571 return SWIG_NewPointerObj(
572 (
void*)dynamic_cast<const HOM_Volume* const>(prim),
573 SWIGTYPE_p_HOM_Volume, own);
575 case HOM_primType::VDB_Id:
576 return SWIG_NewPointerObj(
577 (
void*)dynamic_cast<const HOM_VDB* const>(prim),
578 SWIGTYPE_p_HOM_VDB, own);
580 case HOM_primType::ChannelPrim_Id:
581 return SWIG_NewPointerObj(
582 (
void*)dynamic_cast<const HOM_ChannelPrim* const>(prim),
583 SWIGTYPE_p_HOM_ChannelPrim, own);
588 return SWIG_NewPointerObj(prim, SWIGTYPE_p_HOM_Prim, own);
591 template <> InterpreterObject
592 HOMconvertValueForInterpreter<HOM_ParmTemplate*>(
596 return SWIG_NewPointerObj(
597 parm_template, SWIGTYPE_p_HOM_ParmTemplate, own);
602 switch (parm_template->type().id())
604 case HOM_parmTemplateType::Int_Id:
605 return SWIG_NewPointerObj(
606 (
void*)dynamic_cast<const HOM_IntParmTemplate* const>(
608 SWIGTYPE_p_HOM_IntParmTemplate, own);
610 case HOM_parmTemplateType::Float_Id:
611 return SWIG_NewPointerObj(
612 (
void*)dynamic_cast<const HOM_FloatParmTemplate* const>(
614 SWIGTYPE_p_HOM_FloatParmTemplate, own);
616 case HOM_parmTemplateType::String_Id:
617 return SWIG_NewPointerObj(
618 (
void*)dynamic_cast<const HOM_StringParmTemplate* const>(
620 SWIGTYPE_p_HOM_StringParmTemplate, own);
622 case HOM_parmTemplateType::Data_Id:
623 return SWIG_NewPointerObj(
624 (
void*)dynamic_cast<const HOM_DataParmTemplate* const>(
626 SWIGTYPE_p_HOM_DataParmTemplate, own);
628 case HOM_parmTemplateType::Toggle_Id:
629 return SWIG_NewPointerObj(
630 (
void*)dynamic_cast<const HOM_ToggleParmTemplate* const>(
632 SWIGTYPE_p_HOM_ToggleParmTemplate, own);
634 case HOM_parmTemplateType::Menu_Id:
635 return SWIG_NewPointerObj(
636 (
void*)dynamic_cast<const HOM_MenuParmTemplate* const>(
638 SWIGTYPE_p_HOM_MenuParmTemplate, own);
640 case HOM_parmTemplateType::Button_Id:
641 return SWIG_NewPointerObj(
642 (
void*)dynamic_cast<const HOM_ButtonParmTemplate* const>(
644 SWIGTYPE_p_HOM_ButtonParmTemplate, own);
646 case HOM_parmTemplateType::Label_Id:
647 return SWIG_NewPointerObj(
648 (
void*)dynamic_cast<const HOM_LabelParmTemplate* const>(
650 SWIGTYPE_p_HOM_LabelParmTemplate, own);
652 case HOM_parmTemplateType::Separator_Id:
653 return SWIG_NewPointerObj(
654 (
void*)dynamic_cast<const HOM_SeparatorParmTemplate* const>(
656 SWIGTYPE_p_HOM_SeparatorParmTemplate, own);
658 case HOM_parmTemplateType::FolderSet_Id:
659 return SWIG_NewPointerObj(
660 (
void*)dynamic_cast<const HOM_FolderSetParmTemplate* const>(
662 SWIGTYPE_p_HOM_FolderSetParmTemplate, own);
664 case HOM_parmTemplateType::Folder_Id:
665 return SWIG_NewPointerObj(
666 (
void*)dynamic_cast<const HOM_FolderParmTemplate* const>(
668 SWIGTYPE_p_HOM_FolderParmTemplate, own);
670 case HOM_parmTemplateType::Ramp_Id:
671 return SWIG_NewPointerObj(
672 (
void*)dynamic_cast<const HOM_RampParmTemplate* const>(
674 SWIGTYPE_p_HOM_RampParmTemplate, own);
677 UT_ASSERT(!
"Unknown parm template type");
678 return SWIG_NewPointerObj(parm_template, SWIGTYPE_p_HOM_ParmTemplate, own);
681 template <> InterpreterObject
682 HOMconvertValueForInterpreter<HOM_PaneTab*>(
686 return SWIG_NewPointerObj(pane_tab, SWIGTYPE_p_HOM_PaneTab, own);
692 switch (pane_tab->type().id())
694 case HOM_paneTabType::ContextViewer_Id:
695 return SWIG_NewPointerObj(
696 (
void*)dynamic_cast<const HOM_ContextViewer* const>(pane_tab),
697 SWIGTYPE_p_HOM_ContextViewer, own);
699 case HOM_paneTabType::SceneViewer_Id:
700 return SWIG_NewPointerObj(
701 (
void*)dynamic_cast<const HOM_SceneViewer* const>(pane_tab),
702 SWIGTYPE_p_HOM_SceneViewer, own);
704 case HOM_paneTabType::CompositorViewer_Id:
705 return SWIG_NewPointerObj(
706 (
void*)dynamic_cast<const HOM_CompositorViewer* const>(pane_tab),
707 SWIGTYPE_p_HOM_CompositorViewer, own);
709 case HOM_paneTabType::NetworkEditor_Id:
710 case HOM_paneTabType::ApexEditor_Id:
711 return SWIG_NewPointerObj(
712 (
void*)dynamic_cast<const HOM_NetworkEditor* const>(pane_tab),
713 SWIGTYPE_p_HOM_NetworkEditor, own);
715 case HOM_paneTabType::HelpBrowser_Id:
716 return SWIG_NewPointerObj(
717 (
void*)dynamic_cast<const HOM_HelpBrowser* const>(pane_tab),
718 SWIGTYPE_p_HOM_HelpBrowser, own);
720 case HOM_paneTabType::PythonPanel_Id:
721 return SWIG_NewPointerObj(
722 (
void*)dynamic_cast<const HOM_PythonPanel* const>(pane_tab),
723 SWIGTYPE_p_HOM_PythonPanel, own);
725 case HOM_paneTabType::IPRViewer_Id:
726 return SWIG_NewPointerObj(
727 (
void*)dynamic_cast<const HOM_IPRViewer* const>(pane_tab),
728 SWIGTYPE_p_HOM_IPRViewer, own);
730 case HOM_paneTabType::AssetBrowser_Id:
731 return SWIG_NewPointerObj(
732 (
void*)dynamic_cast<const HOM_AssetBrowser* const>(pane_tab),
733 SWIGTYPE_p_HOM_AssetBrowser, own);
735 case HOM_paneTabType::PerformanceMonitor_Id:
736 return SWIG_NewPointerObj(
737 (
void*)dynamic_cast<const HOM_PerformanceMonitor* const>(pane_tab),
738 SWIGTYPE_p_HOM_PerformanceMonitor, own);
740 case HOM_paneTabType::ChannelEditor_Id:
741 return SWIG_NewPointerObj(
742 (
void*)dynamic_cast<const HOM_ChannelEditorPane* const>(pane_tab),
743 SWIGTYPE_p_HOM_ChannelEditorPane, own);
745 case HOM_paneTabType::DataTree_Id:
746 return SWIG_NewPointerObj(
747 (
void*)dynamic_cast<const HOM_DataTree* const>(pane_tab),
748 SWIGTYPE_p_HOM_DataTree, own);
750 case HOM_paneTabType::SceneGraphTree_Id:
751 return SWIG_NewPointerObj(
752 (
void*)dynamic_cast<const HOM_SceneGraphTree* const>(pane_tab),
753 SWIGTYPE_p_HOM_SceneGraphTree, own);
755 case HOM_paneTabType::Parm_Id:
756 return SWIG_NewPointerObj(
757 (
void*)dynamic_cast<const HOM_ParameterEditor* const>(pane_tab),
758 SWIGTYPE_p_HOM_ParameterEditor, own);
760 case HOM_paneTabType::DetailsView_Id:
761 return SWIG_NewPointerObj(
762 (
void*)dynamic_cast<const HOM_GeometrySpreadsheet * const>(pane_tab),
763 SWIGTYPE_p_HOM_GeometrySpreadsheet, own);
765 case HOM_paneTabType::ChannelViewer_Id:
766 case HOM_paneTabType::OutputViewer_Id:
767 case HOM_paneTabType::ShaderViewer_Id:
768 case HOM_paneTabType::TreeView_Id:
769 case HOM_paneTabType::RenderGallery_Id:
770 return SWIG_NewPointerObj(
771 (
void*)dynamic_cast<const HOM_PathBasedPaneTab* const>(pane_tab),
772 SWIGTYPE_p_HOM_PathBasedPaneTab, own);
774 case HOM_paneTabType::ChannelList_Id:
775 case HOM_paneTabType::Textport_Id:
776 case HOM_paneTabType::PythonShell_Id:
777 case HOM_paneTabType::HandleList_Id:
778 case HOM_paneTabType::BundleList_Id:
779 case HOM_paneTabType::TakeList_Id:
780 case HOM_paneTabType::ParmSpreadsheet_Id:
781 case HOM_paneTabType::LightLinker_Id:
782 case HOM_paneTabType::MaterialPalette_Id:
783 case HOM_paneTabType::EngineSessionSync_Id:
784 return SWIG_NewPointerObj(pane_tab, SWIGTYPE_p_HOM_PaneTab, own);
788 return SWIG_NewPointerObj(pane_tab, SWIGTYPE_p_HOM_PaneTab, own);
791 template <> InterpreterObject
792 HOMconvertValueForInterpreter<HOM_SopVerb*>(
795 return SWIG_NewPointerObj(verb, SWIGTYPE_p_HOM_SopVerb, own);
798 template <> InterpreterObject
799 HOMconvertValueForInterpreter<HOM_Geometry*>(
802 return SWIG_NewPointerObj(geo, SWIGTYPE_p_HOM_Geometry, own);
805 template <> InterpreterObject
806 HOMconvertValueForInterpreter<HOM_NetworkItem*>(
814 switch (item->networkItemType().id())
816 case HOM_networkItemType::Node_Id:
817 return HOMconvertValueForInterpreter(
818 dynamic_cast<HOM_Node* const>(item), own);
820 case HOM_networkItemType::NetworkBox_Id:
821 return HOMconvertValueForInterpreter(
822 dynamic_cast<HOM_NetworkBox* const>(item), own);
824 case HOM_networkItemType::StickyNote_Id:
825 return HOMconvertValueForInterpreter(
826 dynamic_cast<HOM_StickyNote* const>(item), own);
828 case HOM_networkItemType::SubnetIndirectInput_Id:
829 return HOMconvertValueForInterpreter(
830 dynamic_cast<HOM_SubnetIndirectInput* const>(item), own);
832 case HOM_networkItemType::Connection_Id:
833 return HOMconvertValueForInterpreter(
834 dynamic_cast<HOM_NodeConnection* const>(item), own);
836 case HOM_networkItemType::NetworkDot_Id:
837 return HOMconvertValueForInterpreter(
838 dynamic_cast<HOM_NetworkDot* const>(item), own);
845 return SWIG_NewPointerObj(item, SWIGTYPE_p_HOM_NetworkItem, own);
848 template <> InterpreterObject
849 HOMconvertValueForInterpreter<HOM_NetworkMovableItem*>(
853 return SWIG_NewPointerObj(item, SWIGTYPE_p_HOM_NetworkMovableItem, own);
855 return HOMconvertValueForInterpreter<HOM_NetworkItem *>(item, own);
858 template <> InterpreterObject
859 HOMconvertValueForInterpreter<
860 std::vector<HOM_ElemPtr<HOM_NodeConnection> >*>(
861 std::vector<HOM_ElemPtr<HOM_NodeConnection> > *
const &list,
864 return swig::from(*list);
867 template <> InterpreterObject
868 HOMconvertValueForInterpreter<HOM_DopData*>(
HOM_DopData *
const &
data,
int own)
873 return SWIG_NewPointerObj(
874 (
void *)dop_object, SWIGTYPE_p_HOM_DopObject, own);
878 if (dop_relationship)
879 return SWIG_NewPointerObj(
880 (
void *)dop_relationship, SWIGTYPE_p_HOM_DopRelationship, own);
882 return SWIG_NewPointerObj(data, SWIGTYPE_p_HOM_DopData, own);
885 template <> InterpreterObject
886 HOMconvertValueForInterpreter<HOM_RadialItem*>(
891 switch (item->type().id())
893 case HOM_radialItemType::Script_Id:
894 return SWIG_NewPointerObj(
895 (
void*)dynamic_cast<const HOM_RadialScriptItem* const>(item),
896 SWIGTYPE_p_HOM_RadialScriptItem, own);
898 case HOM_radialItemType::Submenu_Id:
899 return SWIG_NewPointerObj(
900 (
void*)dynamic_cast<const HOM_RadialSubmenu* const>(item),
901 SWIGTYPE_p_HOM_RadialSubmenu, own);
908 return SWIG_NewPointerObj(item, SWIGTYPE_p_HOM_RadialItem, own);
911 template <> InterpreterObject
912 HOMconvertValueForInterpreter<HOM_EnumValue*>(
920 return SWIG_NewPointerObj((
void*)item, SWIGTYPE_p_HOM_EnumValue, 0);
925 #define HOM_PROVIDE_SWIG_LOOKUP(type) \
926 template <> InterpreterObject HOMconvertValueForInterpreter<type*>( \
927 type* const& value, int own) \
929 return SWIG_NewPointerObj(SWIG_as_voidptr(value), \
930 SWIGTYPE_p_ ## type, own); \
1022 #define HOM_CONVERT_AND_CATCH \
1025 $result = HOMconvertValueForInterpreter($1, $owner); \
1029 (void)hom::raise_swig_exception(); \
1030 $result = nullptr; \
1035 HOM_CONVERT_AND_CATCH
1039 HOM_CONVERT_AND_CATCH
1043 HOM_CONVERT_AND_CATCH
1047 HOM_CONVERT_AND_CATCH
1051 HOM_CONVERT_AND_CATCH
1055 HOM_CONVERT_AND_CATCH
1059 HOM_CONVERT_AND_CATCH
1063 HOM_CONVERT_AND_CATCH
1067 HOM_CONVERT_AND_CATCH
1071 HOM_CONVERT_AND_CATCH
1075 HOM_CONVERT_AND_CATCH
1079 HOM_CONVERT_AND_CATCH
1083 HOM_CONVERT_AND_CATCH
1087 HOM_CONVERT_AND_CATCH
1091 HOM_CONVERT_AND_CATCH
1095 HOM_CONVERT_AND_CATCH
1099 HOM_CONVERT_AND_CATCH
1103 HOM_CONVERT_AND_CATCH
1107 HOM_CONVERT_AND_CATCH
1111 HOM_CONVERT_AND_CATCH
1118 %typemap(
throws) HOM_TypeError %{
1119 SWIG_exception_fail(SWIG_TypeError, $1.instanceMessage().c_str());
1122 %typemap(
throws) HOM_ValueError %{
1123 SWIG_exception_fail(SWIG_ValueError, $1.instanceMessage().c_str());
1128 PyErr_SetObject(PyExc_SystemExit, SWIG_From_int($1.code()));
1138 %typemap(in) hboost::
any {
1143 HOMinterpreterObjectToBoostAny($input, $1);
1147 (
void)hom::raise_swig_exception();
1159 HOMinterpreterObjectToUTOptionAny($input, $1);
1163 (
void)hom::raise_swig_exception();
1168 %typemap(out) hboost::any {
1171 $result = HOMboostAnyToInterpreterObject($1);
1175 (
void)hom::raise_swig_exception();
1182 $result = HOMDDSourceAnyToInterpreterObject($1);
1186 (
void)hom::raise_swig_exception();
1196 if ($input != Py_None)
1200 if (SWIG_IsOK(SWIG_AsVal_double($input, &res)))
1208 (
void)hom::raise_swig_exception();
1216 if ($input != Py_None)
1220 if (SWIG_IsOK(SWIG_AsVal_int($input, &res)))
1228 (
void)hom::raise_swig_exception();
1232 %typemap(out) HOM_OptionalInt {
1236 $result = SWIG_From_int($1.
value());
1238 $result = SWIG_Py_Void();
1242 (
void)hom::raise_swig_exception();
1250 $result = HOMincRef((InterpreterObject)$1.opaqueObject());
1260 struct traits_from<PY_OpaqueObject>
1262 static PyObject *from(
const PY_OpaqueObject &
val)
1264 return HOMincRef((InterpreterObject)val.
opaqueObject());
1270 template <
typename T>
1273 swig_type_info *descriptor)
1276 int res = SWIG_ConvertPtr(input, &t_ptr, descriptor, 0);;
1277 if (SWIG_IsOK(res) && t_ptr)
1280 result =
reinterpret_cast<T*
>(t_ptr);
1291 template <
typename Seq,
typename T =
typename Seq::value_type>
1293 HOMinterpreterObjectConvertSeq(InterpreterObject input,
hboost::any &result)
1295 swig::SwigPySequence_Cont<T> swigpyseq(input);
1296 if (!swigpyseq.check())
1299 auto n = swigpyseq.size();
1302 for (
auto i=0;i<
n; ++i)
1303 seq[i] = swigpyseq[i];
1305 result = std::move(seq);
1310 template <
typename T>
1312 HOMinterpreterObjectConvertVal(InterpreterObject input,
hboost::any &result)
1317 swig_type_info *descriptor = swig::type_info<T>();
1322 int res = SWIG_ConvertPtr(input, (
void**)&t_ptr, descriptor, 0);
1324 if (!SWIG_IsOK(res) || !t_ptr)
1332 result = std::move(*t_ptr);
1333 if (SWIG_IsNewObj(res))
1339 template <
typename T>
1341 HOMinterpreterObjectConvertAsPtr(InterpreterObject input,
hboost::any &result)
1345 int res = swig::asptr(input, (T**)NULL);
1346 if (!SWIG_IsOK(res))
1351 res = swig::asptr(input, &t_ptr);
1352 if (!SWIG_IsOK(res) || !t_ptr)
1360 result = std::move(*t_ptr);
1361 if (SWIG_IsNewObj(res))
1367 #define CONVERT_PTR(X) \
1368 if (HOMinterpreterObjectConvertPtr<X>(\
1369 swig_input,result,SWIGTYPE_p_##X))\
1372 #define CONVERT_VAL(X) \
1373 if (HOMinterpreterObjectConvertVal<X>(swig_input,result))\
1376 #define CONVERT_ASPTR(X) \
1377 if (HOMinterpreterObjectConvertAsPtr<X>(input,result))\
1380 #define CONVERT_SEQ(X) \
1381 if (HOMinterpreterObjectConvertSeq<X>(input,result))\
1385 typedef std::map<std::string,hboost::any> std__map_std__string_hboost__any_;
1386 typedef std::vector<std::map<std::string,hboost::any>> std__vector_std__map_std__string_hboost__any__;
1395 HOMinterpreterObjectToBoostAny(InterpreterObject input,
hboost::any &result)
1398 if (input == Py_None)
1400 result = (
void *)NULL;
1406 if (input == Py_True)
1412 if (input == Py_False)
1420 if (SWIG_IsOK(SWIG_AsVal_int(input, &int_result)))
1422 result = int_result;
1426 double double_result;
1427 if (SWIG_IsOK(SWIG_AsVal_double(input, &double_result)))
1429 result = double_result;
1434 char*
buf = 0 ;
size_t size = 0;
int alloc = SWIG_OLDOBJ;
1435 if (SWIG_IsOK((SWIG_AsCharPtrAndSize(input, &buf, &size, &alloc))))
1440 if (alloc == SWIG_NEWOBJ)
1455 bool is_seq = PyList_Check(input) || PyTuple_Check(input);
1456 bool is_dict = PyDict_Check(input);
1459 CONVERT_SEQ(std::vector<int>);
1460 CONVERT_SEQ(std::vector<double>);
1461 CONVERT_SEQ(std::vector<std::string>);
1462 CONVERT_SEQ(std::vector<HOM_Quaternion>);
1463 CONVERT_SEQ(std::vector<HOM_Vector2>);
1464 CONVERT_SEQ(std::vector<HOM_Vector3>);
1465 CONVERT_SEQ(std::vector<HOM_Vector4>);
1466 CONVERT_SEQ(std::vector<HOM_Matrix2>);
1467 CONVERT_SEQ(std::vector<HOM_Matrix3>);
1468 CONVERT_SEQ(std::vector<HOM_Matrix4>);
1469 CONVERT_SEQ(std__vector_std__map_std__string_hboost__any__);
1473 CONVERT_ASPTR(std__map_std__string_hboost__any_);
1480 InterpreterObject swig_input =
1481 (InterpreterObject)SWIG_Python_GetSwigThis(input);
1499 CONVERT_VAL(std::vector<int>);
1500 CONVERT_VAL(std::vector<double>);
1501 CONVERT_VAL(std::vector<std::string>);
1502 CONVERT_VAL(std::vector<HOM_Quaternion>);
1503 CONVERT_VAL(std::vector<HOM_Vector2>);
1504 CONVERT_VAL(std::vector<HOM_Vector3>);
1505 CONVERT_VAL(std::vector<HOM_Vector4>);
1506 CONVERT_VAL(std::vector<HOM_Matrix2>);
1507 CONVERT_VAL(std::vector<HOM_Matrix3>);
1508 CONVERT_VAL(std::vector<HOM_Matrix4>);
1509 CONVERT_VAL(std__map_std__string_hboost__any_);
1510 CONVERT_VAL(std__vector_std__map_std__string_hboost__any__);
1523 HOMinterpreterObjectToUTOptionAny(InterpreterObject input,
1524 HOM_UTOptionAny &result)
1526 return HOMinterpreterObjectToBoostAny(input, result);
1534 struct traits_asptr<hboost::any>
1540 HOMinterpreterObjectToBoostAny(obj, *p);
1555 static InterpreterObject
1556 HOMboostAnyToInterpreterObject(
const hboost::any &result)
1559 return SWIG_Py_Void();
1561 namespace ti = hboost::typeindex;
1563 if (result.type() == ti::type_id<int>())
1564 return SWIG_From_int(hboost::any_cast<int>(result));
1566 if (result.type() == ti::type_id<long>())
1567 return SWIG_From_long(hboost::any_cast<long>(result));
1569 if (result.type() == ti::type_id<int64>())
1570 return swig::from(hboost::any_cast<int64>(result));
1572 if (result.type() == ti::type_id<float>())
1573 return SWIG_From_float(hboost::any_cast<float>(result));
1575 if (result.type() == ti::type_id<double>())
1576 return SWIG_From_double(hboost::any_cast<double>(result));
1578 if (result.type() == ti::type_id<bool>())
1579 return SWIG_From_bool(hboost::any_cast<bool>(result));
1581 if (result.type() == ti::type_id<std::string>())
1582 return SWIG_From_std_string(hboost::any_cast<std::string>(result));
1584 if (result.type() == ti::type_id<HOM_BinaryString>())
1585 return SWIG_From_HOM_BinaryString(hboost::any_cast<HOM_BinaryString>(result));
1587 if (result.type() == ti::type_id<std::map<std::string, hboost::any>>())
1589 hboost::any_cast<std::map<std::string, hboost::any> >(result));
1591 if (result.type() == ti::type_id<std::vector<int>>())
1592 return swig::from(hboost::any_cast<std::vector<int> >(result));
1594 if (result.type() == ti::type_id<std::vector<int64>>())
1595 return swig::from(hboost::any_cast<std::vector<int64> >(result));
1597 if (result.type() == ti::type_id<std::vector<float>>())
1598 return swig::from(hboost::any_cast<std::vector<float> >(result));
1600 if (result.type() == ti::type_id<std::vector<std::string>>())
1601 return swig::from(hboost::any_cast<std::vector<std::string> >(result));
1603 if (result.type() == ti::type_id<std::vector<double>>())
1604 return swig::from(hboost::any_cast<std::vector<double> >(result));
1606 if (result.type() == ti::type_id<std::vector<std::vector<float> >>())
1608 hboost::any_cast<std::vector<std::vector<float> > >(result));
1610 if (result.type() == ti::type_id<std::vector<std::vector<double> >>())
1612 hboost::any_cast<std::vector<std::vector<double> > >(result));
1614 if (result.type() == ti::type_id<std::vector<std::map<std::string, hboost::any> >>())
1616 hboost::any_cast<std::vector<std::map<std::string, hboost::any> > >(result));
1620 if (result.type() == ti::type_id<HOM_Vector2 *>())
1621 return HOMconvertValueForInterpreter(
1622 hboost::any_cast<HOM_Vector2 *>(result), SWIG_POINTER_OWN);
1624 if (result.type() == ti::type_id<HOM_Vector3 *>())
1625 return HOMconvertValueForInterpreter(
1626 hboost::any_cast<HOM_Vector3 *>(result), SWIG_POINTER_OWN);
1628 if (result.type() == ti::type_id<HOM_Vector4 *>())
1629 return HOMconvertValueForInterpreter(
1630 hboost::any_cast<HOM_Vector4 *>(result), SWIG_POINTER_OWN);
1632 if (result.type() == ti::type_id<HOM_Matrix2 *>())
1633 return HOMconvertValueForInterpreter(
1634 hboost::any_cast<HOM_Matrix2 *>(result), SWIG_POINTER_OWN);
1636 if (result.type() == ti::type_id<HOM_Matrix3 *>())
1637 return HOMconvertValueForInterpreter(
1638 hboost::any_cast<HOM_Matrix3 *>(result), SWIG_POINTER_OWN);
1640 if (result.type() == ti::type_id<HOM_Matrix4 *>())
1641 return HOMconvertValueForInterpreter(
1642 hboost::any_cast<HOM_Matrix4 *>(result), SWIG_POINTER_OWN);
1644 if (result.type() == ti::type_id<HOM_Quaternion *>())
1645 return HOMconvertValueForInterpreter(
1646 hboost::any_cast<HOM_Quaternion *>(result), SWIG_POINTER_OWN);
1648 if (result.type() == ti::type_id<HOM_NodeType *>())
1649 return HOMconvertValueForInterpreter(
1650 hboost::any_cast<HOM_NodeType *>(result), SWIG_POINTER_OWN);
1652 if (result.type() == ti::type_id<HOM_Ramp *>())
1653 return HOMconvertValueForInterpreter(
1654 hboost::any_cast<HOM_Ramp *>(result), SWIG_POINTER_OWN);
1656 if (result.type() == ti::type_id<HOM_Color *>())
1657 return HOMconvertValueForInterpreter(
1658 hboost::any_cast<HOM_Color *>(result), SWIG_POINTER_OWN);
1660 if (result.type() == ti::type_id<HOM_Parm *>())
1661 return HOMconvertValueForInterpreter(
1662 hboost::any_cast<HOM_Parm *>(result), SWIG_POINTER_OWN);
1664 if (result.type() == ti::type_id<HOM_EnumValue *>())
1665 return HOMconvertValueForInterpreter(
1666 hboost::any_cast<HOM_EnumValue *>(result), 0);
1668 if (result.type() == ti::type_id<HOM_Geometry *>())
1669 return HOMconvertValueForInterpreter(
1670 hboost::any_cast<HOM_Geometry *>(result), SWIG_POINTER_OWN);
1672 if (result.type() == ti::type_id<std::vector<HOM_ElemPtr<HOM_Vector2> >>())
1676 if (result.type() == ti::type_id<std::vector<HOM_ElemPtr<HOM_Vector3> >>())
1680 if (result.type() == ti::type_id<std::vector<HOM_ElemPtr<HOM_Vector4> >>())
1684 if (result.type() == ti::type_id<std::vector<HOM_ElemPtr<HOM_Matrix2> >>())
1688 if (result.type() == ti::type_id<std::vector<HOM_ElemPtr<HOM_Matrix3> >>())
1692 if (result.type() == ti::type_id<std::vector<HOM_ElemPtr<HOM_Matrix4> >>())
1696 if (result.type() == ti::type_id<std::vector<HOM_ElemPtr<HOM_Quaternion> >>())
1700 #if UT_ASSERT_LEVEL > 0
1701 std::cout <<
"Unknown data type: "
1705 return SWIG_Py_Void();
1710 static InterpreterObject
1711 HOMDDSourceAnyToInterpreterObject(
const HOM_DDSourceAny &result)
1713 namespace ti = hboost::typeindex;
1715 if (result.type() == ti::type_id<HOM_Node *>())
1717 return HOMconvertValueForInterpreter(
1718 hboost::any_cast<HOM_Node *>(result), SWIG_POINTER_OWN);
1720 if (result.type() == ti::type_id<HOM_Parm *>())
1722 return HOMconvertValueForInterpreter(
1723 hboost::any_cast<HOM_Parm *>(result), SWIG_POINTER_OWN);
1725 if (result.type() == ti::type_id<HOM_GalleryEntry *>())
1727 return HOMconvertValueForInterpreter(
1728 hboost::any_cast<HOM_GalleryEntry *>(result), SWIG_POINTER_OWN);
1731 return HOMboostAnyToInterpreterObject(result);
1738 struct traits_from<hboost::any>
1741 {
return HOMboostAnyToInterpreterObject(val); }
1745 static InterpreterObject
1746 HOMoptionsToInterpreterObject(
const UT_Options &options);
1748 static InterpreterObject
1749 HOMoptionEntryToInterpreterObject(
const UT_OptionEntry &option_entry)
1755 InterpreterObject result = NULL;
1757 switch (option_entry.
getType())
1764 return SWIG_From_bool(
1768 return SWIG_From_double(
1774 return SWIG_From_std_string(
1779 return HOMconvertValueForInterpreter(
1785 return HOMconvertValueForInterpreter(
1791 return HOMconvertValueForInterpreter(
1797 return HOMconvertValueForInterpreter(
1803 return HOMconvertValueForInterpreter(
1809 return HOMconvertValueForInterpreter(
1815 return HOMconvertValueForInterpreter(
1821 return HOMconvertValueForInterpreter(
1827 return HOMconvertValueForInterpreter(
1834 std::vector<int64> int_vector;
1836 static_cast<const UT_OptionInt64Array &>(option_entry)
1837 .getValue(), int_vector);
1838 return swig::from(int_vector);
1843 std::vector<double> double_vector;
1845 static_cast<const UT_OptionFpreal64Array &>(option_entry)
1846 .getValue(), double_vector);
1847 return swig::from(double_vector);
1852 std::vector<std::string> str_vector;
1853 UTarrayToStdVectorOfStrings(
1854 static_cast<const UT_OptionStringArray &>(option_entry)
1855 .getValue(), str_vector);
1856 return swig::from(str_vector);
1862 opt =
static_cast<const UT_OptionDict &
>(option_entry).getValue();
1863 return HOMoptionsToInterpreterObject(*opt.
options());
1869 InterpreterObject result = PyList_New(0);
1871 for (
auto && opt : optlist)
1873 PyList_Append(result, HOMoptionsToInterpreterObject(*opt.
options()));
1884 return result ? result : SWIG_Py_Void();
1888 static InterpreterObject
1889 HOMoptionsToInterpreterObject(
const UT_Options &options)
1895 InterpreterObject result = PyDict_New();
1901 InterpreterObject value=HOMoptionEntryToInterpreterObject(*it.entry());
1902 PyDict_SetItemString(result, it.name(),
value);
1909 static InterpreterObject
1910 HOMoptionsListToInterpreterObject(
const std::vector<UT_Options>& options)
1912 auto pysize = options.size();
1918 InterpreterObject list = PyList_New(pysize);
1919 for (
int i = 0; i < pysize; ++i)
1921 auto value = HOMoptionsToInterpreterObject(options[i]);
1923 PyList_SET_ITEM(list, i, value);
1934 template<
typename T>
1935 PyObject* HOMgetattr(T* hom_object,
const char *
name)
1943 PyObject *dict = context
1946 ? PyDict_GetItemString(dict, name) : NULL;
1949 if (!attribute && dict)
1952 attribute = name ? PyDict_GetItemString(dict, name) : NULL;
1958 return HOMincRef(attribute);
1964 error_message.
sprintf(
"'module' object has no attribute '%s'", name);
1965 PyErr_SetString(PyExc_AttributeError, error_message.
buffer());
1979 HOM_PyBuffer(InterpreterObject py_object)
1981 #if PY_VERSION_HEX >= 0x03000000
1982 myBytesObj =
nullptr;
1987 PyObject *obj = py_object;
1989 #if PY_VERSION_HEX >= 0x03000000
1991 if (PyUnicode_Check(obj))
1994 PyUnicode_AsEncodedString(obj,
"utf-8",
"surrogateescape");
2000 #if PY_VERSION_HEX >= 0x02060000
2001 myUseNewAPI =
false;
2002 if (PyObject_CheckBuffer(obj))
2004 if (PyObject_GetBuffer(obj, &myPyBuffer, PyBUF_SIMPLE) < 0)
2006 #if PY_VERSION_HEX >= 0x03000000
2007 cleanBytesObject_();
2009 throw HOM_TypeError(
"failed to get readable buffer");
2013 myData = myPyBuffer.buf;
2014 myLength = myPyBuffer.len;
2019 #if PY_VERSION_HEX >= 0x03000000
2020 cleanBytesObject_();
2021 throw HOM_TypeError(
"failed to get readable buffer");
2025 if (!PyObject_CheckReadBuffer(obj))
2026 throw HOM_TypeError(
"expected a readable buffer");
2028 if (PyObject_AsReadBuffer(obj, &myData, &myLength) < 0)
2029 throw HOM_TypeError(
"failed to get readable buffer");
2035 #if PY_VERSION_HEX >= 0x03000000
2036 cleanBytesObject_();
2039 #if PY_VERSION_HEX >= 0x02060000
2041 PyBuffer_Release(&myPyBuffer);
2045 #if PY_VERSION_HEX >= 0x03000000
2046 void cleanBytesObject_()
2051 Py_DECREF(myBytesObj);
2052 myBytesObj =
nullptr;
2056 #if PY_VERSION_HEX >= 0x03000000
2057 PyObject *myBytesObj;
2060 #if PY_VERSION_HEX >= 0x02060000
2062 Py_buffer myPyBuffer;
2065 Py_ssize_t myLength;
2075 template <
typename T,
typename A>
2077 HOMattribValue(T &geo_element,
A &hom_attrib,
2083 InterpreterObject result = NULL;
2084 const bool scalar = (attr_size == 1 && !is_array_type);
2085 switch (array_data_type)
2087 case HOM_attribData::Int_Id:
2089 result = swig::from(
2090 hboost::any_cast<int64>(geo_element.intAttribValue(hom_attrib)));
2092 result = swig::from(
2093 hboost::any_cast<std::vector<int64> >(
2094 geo_element.intListAttribValue(hom_attrib)));
2097 case HOM_attribData::Float_Id:
2099 result = SWIG_From_double(geo_element.floatAttribValue(hom_attrib));
2101 result = swig::from(geo_element.floatListAttribValue(hom_attrib));
2104 case HOM_attribData::String_Id:
2106 result = SWIG_From_std_string(
2107 geo_element.stringAttribValue(hom_attrib));
2109 result = swig::from(geo_element.stringListAttribValue(hom_attrib));
2112 case HOM_attribData::Dict_Id:
2114 result = swig::from(geo_element.dictAttribValue(hom_attrib));
2116 result = swig::from(geo_element.dictListAttribValue(hom_attrib));
2123 template <
typename T>
2125 HOMattribValue(T &geo_element,
HOM_Attrib &hom_attrib)
2127 return HOMattribValue(geo_element,
2134 template <
typename T>
2136 HOMattribValue(T &geo_element,
const char *name)
2139 bool is_array_type =
false;
2140 int attr_data_type = 0;
2141 geo_element._attribInfo(name,attr_data_type,attr_size,is_array_type);
2142 return HOMattribValue(geo_element,name, attr_size, is_array_type,
2151 static InterpreterObject
2156 case HOM_parmData::Int_Id:
2158 case HOM_parmData::Float_Id:
2160 case HOM_parmData::String_Id:
2162 case HOM_parmData::Ramp_Id:
2163 return SWIG_NewPointerObj(
2164 (
void*)parm.
evalAsRamp(), SWIGTYPE_p_HOM_Ramp, SWIG_POINTER_OWN);
2165 case HOM_parmData::Data_Id:
2169 return SWIG_NewPointerObj(
2170 (
void*)parm.
evalAsGeometry(), SWIGTYPE_p_HOM_Geometry, SWIG_POINTER_OWN);
2174 return SWIG_Py_Void();
2177 static InterpreterObject
2178 HOMevalParmAtFrame(
HOM_Parm &parm,
double frame)
2182 case HOM_parmData::Int_Id:
2184 case HOM_parmData::Float_Id:
2186 case HOM_parmData::String_Id:
2188 case HOM_parmData::Ramp_Id:
2189 return SWIG_NewPointerObj(
2191 SWIGTYPE_p_HOM_Ramp, SWIG_POINTER_OWN);
2192 case HOM_parmData::Data_Id:
2196 return SWIG_NewPointerObj(
2198 SWIGTYPE_p_HOM_Geometry, SWIG_POINTER_OWN);
2202 return SWIG_Py_Void();
2205 static InterpreterObject
2210 case HOM_parmData::Int_Id:
2212 case HOM_parmData::Float_Id:
2214 case HOM_parmData::String_Id:
2216 case HOM_parmData::Ramp_Id:
2218 case HOM_parmData::Data_Id:
2220 == HOM_dataParmType::KeyValueDictionary_Id)
2229 return SWIG_Py_Void();
2232 static InterpreterObject
2233 HOMevalParmTupleAtFrame(
HOM_ParmTuple &parm_tuple,
double frame)
2237 case HOM_parmData::Int_Id:
2239 case HOM_parmData::Float_Id:
2241 case HOM_parmData::String_Id:
2243 case HOM_parmData::Ramp_Id:
2245 case HOM_parmData::Data_Id:
2247 == HOM_dataParmType::KeyValueDictionary_Id)
2256 return SWIG_Py_Void();
2259 static InterpreterObject
2264 case HOM_parmData::Int_Id:
2266 case HOM_parmData::Float_Id:
2268 case HOM_parmData::String_Id:
2270 case HOM_parmData::Ramp_Id:
2271 return SWIG_NewPointerObj(
2272 (
void*)visualizer.
evalParmAsRamp(parm_name), SWIGTYPE_p_HOM_Ramp,
2277 return SWIG_Py_Void();
UT_Matrix4T< double > UT_DMatrix4
virtual std::vector< HOM_ElemPtr< HOM_Geometry > > evalAsGeometries()=0
GLenum GLuint GLenum GLsizei const GLchar * buf
UT_Matrix3T< double > UT_DMatrix3
virtual std::vector< int > evalAsIntsAtFrame(double frame)=0
virtual std::string evalParmAsString(const char *parm_name)=0
virtual bool isArrayType()=0
virtual std::vector< HOM_ElemPtr< HOM_Ramp > > evalAsRampsAtFrame(double frame)=0
hboost::any HOM_UTOptionAny
void * opaqueObject() const noexcept
GLsizei const GLchar *const * string
GLsizei const GLfloat * value
virtual int parmDataTypeEnumId()=0
virtual double evalAsFloat()=0
virtual int opTypeIdAsInt()=0
virtual std::vector< int > evalAsInts()=0
SYS_FORCE_INLINE const char * buffer() const
**But if you need a result
std::optional< T > UT_Optional
virtual HOM_Ramp * evalParmAsRamp(const char *parm_name)=0
virtual HOM_Ramp * evalAsRampAtFrame(double frame)=0
virtual std::vector< std::string > evalAsStrings()=0
UT_API std::string UTunmangleClassNameFromTypeIdName(const std::string &name)
virtual double evalAsFloatAtFrame(double frame)=0
virtual std::vector< std::map< std::string, std::string > > evalAsJSONMaps()=0
virtual int evalAsIntAtFrame(double frame)=0
virtual int dataParmTypeEnumId()=0
bool any(const vbool4 &v)
virtual std::map< std::string, std::string > evalAsJSONMapAtFrame(double frame)=0
virtual HOM_Geometry * evalAsGeometryAtFrame(double frame)=0
virtual UT_OptionType getType() const
UT_Matrix2T< double > UT_DMatrix2
virtual std::vector< std::map< std::string, std::string > > evalAsJSONMapsAtFrame(double frame)=0
virtual std::map< std::string, std::string > evalAsJSONMap()=0
UT_Optional< int > HOM_OptionalInt
GLuint const GLchar * name
VULKAN_HPP_INLINE VULKAN_HPP_CONSTEXPR_14 uint8_t packed(VULKAN_HPP_NAMESPACE::Format format)
virtual int parmDataTypeEnumId()=0
virtual std::string evalAsStringAtFrame(double frame)=0
virtual std::vector< HOM_ElemPtr< HOM_Geometry > > evalAsGeometriesAtFrame(double frame)=0
virtual std::vector< double > evalAsFloatsAtFrame(double frame)=0
virtual HOM_Ramp * evalAsRamp()=0
int sprintf(const char *fmt,...) SYS_PRINTF_CHECK_ATTRIBUTE(2
virtual int dataParmTypeEnumId()=0
hboost::any HOM_DDSourceAny
virtual int evalAsInt()=0
virtual std::vector< double > evalAsFloats()=0
A map of string to various well defined value types.
virtual int opTypeIdAsInt()=0
virtual double evalParmAsFloat(const char *parm_name)=0
virtual int parmDataTypeEnumId(const char *parm_name)=0
SYS_FORCE_INLINE const UT_Options * options() const
virtual bool isManager(bool include_management_types=true)=0
OIIO_API bool attribute(string_view name, TypeDesc type, const void *val)
virtual HOM_EnumValue & dataType()=0
UT_Optional< double > HOM_OptionalDouble
Adaptors between UT and std classes.
virtual std::vector< HOM_ElemPtr< HOM_Ramp > > evalAsRamps()=0
virtual int evalParmAsInt(const char *parm_name)=0
HOM_API HOM_Module & HOM()
virtual std::vector< std::string > evalAsStringsAtFrame(double frame)=0
virtual std::string evalAsString()=0
virtual HOM_Geometry * evalAsGeometry()=0