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>(
120 const std::string&
value,
int )
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_CopNode* const>(node),
186 SWIGTYPE_p_HOM_CopNode, own);
193 return SWIG_NewPointerObj(
194 (
void*)dynamic_cast<HOM_DopNode* const>(node),
195 SWIGTYPE_p_HOM_DopNode, own);
202 return SWIG_NewPointerObj(
203 (
void*)dynamic_cast<HOM_ShopNode* const>(node),
204 SWIGTYPE_p_HOM_ShopNode, own);
211 return SWIG_NewPointerObj(
212 (
void*)dynamic_cast<HOM_VopNetNode* const>(node),
213 SWIGTYPE_p_HOM_VopNetNode, own);
220 return SWIG_NewPointerObj(
221 (
void*)dynamic_cast<HOM_RopNode* const>(node),
222 SWIGTYPE_p_HOM_RopNode, own);
229 return SWIG_NewPointerObj(
230 (
void*)dynamic_cast<HOM_VopNode* const>(node),
231 SWIGTYPE_p_HOM_VopNode, own);
238 return SWIG_NewPointerObj(
239 (
void*)dynamic_cast<HOM_TopNode* const>(node),
240 SWIGTYPE_p_HOM_TopNode, own);
250 nodetype = node->type();
251 isnetwork = (nodetype && nodetype->
isManager(
true));
254 return SWIG_NewPointerObj(
255 (
void*)dynamic_cast<HOM_LopNetwork* const>(node),
256 SWIGTYPE_p_HOM_LopNetwork, own);
258 return SWIG_NewPointerObj(
259 (
void*)dynamic_cast<HOM_LopNode* const>(node),
260 SWIGTYPE_p_HOM_LopNode, own);
270 if (
HOM().lopNodeTypeCategory() == node->childTypeCategory())
271 return SWIG_NewPointerObj(
273 SWIGTYPE_p_HOM_LopNetwork, own);
279 return SWIG_NewPointerObj(opnode, SWIGTYPE_p_HOM_OpNode, own);
282 template <> InterpreterObject
283 HOMconvertValueForInterpreter<HOM_NodeType*>(
290 if (!nodetype || (!opnodetype && !apexnodetype))
291 return SWIG_NewPointerObj(nodetype, SWIGTYPE_p_HOM_NodeType, own);
294 return SWIG_NewPointerObj(nodetype, SWIGTYPE_p_HOM_ApexNodeType, own);
296 if( !nodetype->isManager() )
306 return SWIG_NewPointerObj(
307 (
void*)dynamic_cast<const HOM_SopNodeType* const>(nodetype),
308 SWIGTYPE_p_HOM_SopNodeType, own);
315 return SWIG_NewPointerObj(
316 (
void*)dynamic_cast<const HOM_ShopNodeType* const>(nodetype),
317 SWIGTYPE_p_HOM_ShopNodeType, own);
324 return SWIG_NewPointerObj(
325 (
void*)dynamic_cast<const HOM_VopNodeType* const>(nodetype),
326 SWIGTYPE_p_HOM_VopNodeType, own);
332 return SWIG_NewPointerObj(nodetype, SWIGTYPE_p_HOM_OpNodeType, own);
335 template <> InterpreterObject
336 HOMconvertValueForInterpreter<HOM_NodeTypeCategory*>(
344 if (!nodetypecategory || (!opnodetypecategory && !apexnodetypecategory))
345 return SWIG_NewPointerObj(nodetypecategory,
346 SWIGTYPE_p_HOM_NodeTypeCategory, own);
348 if (apexnodetypecategory)
349 return SWIG_NewPointerObj(nodetypecategory,
350 SWIGTYPE_p_HOM_ApexNodeTypeCategory, own);
352 return SWIG_NewPointerObj(nodetypecategory,
353 SWIGTYPE_p_HOM_OpNodeTypeCategory, own);
356 template <> InterpreterObject
357 HOMconvertValueForInterpreter<HOM_NodeTypeCategory&>(
365 if (!opnodetypecategory && !apexnodetypecategory)
366 return SWIG_NewPointerObj(&nodetypecategory,
367 SWIGTYPE_p_HOM_NodeTypeCategory, own);
369 if (apexnodetypecategory)
370 return SWIG_NewPointerObj(&nodetypecategory,
371 SWIGTYPE_p_HOM_ApexNodeTypeCategory, own);
373 return SWIG_NewPointerObj(&nodetypecategory,
374 SWIGTYPE_p_HOM_OpNodeTypeCategory, own);
390 result = HOMconvertValueForInterpreter(val, 0);
406 template <> InterpreterObject
407 HOMconvertValueForInterpreter<HOM_NetworkBox*>(
413 return SWIG_NewPointerObj(obj, SWIGTYPE_p_HOM_NetworkBox, own);
415 return SWIG_NewPointerObj(obj, SWIGTYPE_p_HOM_OpNetworkBox, own);
418 template <> InterpreterObject
419 HOMconvertValueForInterpreter<HOM_NetworkDot*>(
425 return SWIG_NewPointerObj(obj, SWIGTYPE_p_HOM_NetworkDot, own);
427 return SWIG_NewPointerObj(obj, SWIGTYPE_p_HOM_OpNetworkDot, own);
430 template <> InterpreterObject
431 HOMconvertValueForInterpreter<HOM_NodeConnection*>(
437 if (!obj || (!opobj && !apexobj))
438 return SWIG_NewPointerObj(obj, SWIGTYPE_p_HOM_NodeConnection, own);
441 return SWIG_NewPointerObj(obj, SWIGTYPE_p_HOM_ApexNodeConnection, own);
443 return SWIG_NewPointerObj(obj, SWIGTYPE_p_HOM_OpNodeConnection, own);
446 template <> InterpreterObject
447 HOMconvertValueForInterpreter<HOM_StickyNote*>(
453 if (!obj || (!opobj && !apexobj))
454 return SWIG_NewPointerObj(obj, SWIGTYPE_p_HOM_StickyNote, own);
457 return SWIG_NewPointerObj(obj, SWIGTYPE_p_HOM_ApexStickyNote, own);
459 return SWIG_NewPointerObj(obj, SWIGTYPE_p_HOM_OpStickyNote, own);
462 template <> InterpreterObject
463 HOMconvertValueForInterpreter<HOM_SubnetIndirectInput*>(
469 return SWIG_NewPointerObj(obj, SWIGTYPE_p_HOM_SubnetIndirectInput, own);
471 return SWIG_NewPointerObj(obj, SWIGTYPE_p_HOM_OpSubnetIndirectInput, own);
474 template <> InterpreterObject
475 HOMconvertValueForInterpreter<HOM_BaseKeyframe*>(
479 return SWIG_NewPointerObj(keyframe, SWIGTYPE_p_HOM_BaseKeyframe, own);
481 if (keyframe->evaluatedType() == HOM_parmData::Float)
487 return SWIG_NewPointerObj(
488 (
void*)dynamic_cast<const HOM_Keyframe* const>(keyframe),
489 SWIGTYPE_p_HOM_Keyframe, own);
491 else if (keyframe->evaluatedType() == HOM_parmData::String)
497 return SWIG_NewPointerObj(
498 (
void*)dynamic_cast<const HOM_StringKeyframe* const>(keyframe),
499 SWIGTYPE_p_HOM_StringKeyframe, own);
502 return SWIG_NewPointerObj(keyframe, SWIGTYPE_p_HOM_BaseKeyframe, own);
505 template <> InterpreterObject
506 HOMconvertValueForInterpreter<HOM_PackedPrim*>(
HOM_PackedPrim *
const &prim,
int own)
509 return SWIG_NewPointerObj(prim, SWIGTYPE_p_HOM_PackedPrim, own);
516 switch (prim->type().id())
518 case HOM_primType::Agent_Id:
519 return SWIG_NewPointerObj(
520 (
void *)dynamic_cast<HOM_Agent *const>(prim),
521 SWIGTYPE_p_HOM_Agent, own);
523 case HOM_primType::PackedFragment_Id:
524 return SWIG_NewPointerObj(
525 (
void *)dynamic_cast<HOM_PackedFragment *const>(prim),
526 SWIGTYPE_p_HOM_PackedFragment, own);
528 case HOM_primType::PackedGeometry_Id:
529 return SWIG_NewPointerObj(
530 (
void *)dynamic_cast<HOM_PackedGeometry *const>(prim),
531 SWIGTYPE_p_HOM_PackedGeometry, own);
535 return SWIG_NewPointerObj((
void *)prim, SWIGTYPE_p_HOM_PackedPrim, own);
538 template <> InterpreterObject
539 HOMconvertValueForInterpreter<HOM_Prim*>(
HOM_Prim *
const &prim,
int own)
542 return SWIG_NewPointerObj(prim, SWIGTYPE_p_HOM_Prim, own);
550 return HOMconvertValueForInterpreter(packed, own);
552 switch (prim->type().id())
554 case HOM_primType::Polygon_Id:
555 return SWIG_NewPointerObj(
556 (
void*)dynamic_cast<const HOM_Polygon* const>(prim),
557 SWIGTYPE_p_HOM_Polygon, own);
559 case HOM_primType::NURBSCurve_Id:
560 case HOM_primType::BezierCurve_Id:
561 return SWIG_NewPointerObj(
562 (
void*)dynamic_cast<const HOM_Face* const>(prim),
563 SWIGTYPE_p_HOM_Face, own);
565 case HOM_primType::Mesh_Id:
566 case HOM_primType::NURBSSurface_Id:
567 case HOM_primType::BezierSurface_Id:
568 return SWIG_NewPointerObj(
569 (
void*)dynamic_cast<const HOM_Surface* const>(prim),
570 SWIGTYPE_p_HOM_Surface, own);
572 case HOM_primType::Circle_Id:
573 case HOM_primType::Sphere_Id:
574 case HOM_primType::Tube_Id:
575 return SWIG_NewPointerObj(
576 (
void*)dynamic_cast<const HOM_Quadric* const>(prim),
577 SWIGTYPE_p_HOM_Quadric, own);
579 case HOM_primType::Volume_Id:
580 return SWIG_NewPointerObj(
581 (
void*)dynamic_cast<const HOM_Volume* const>(prim),
582 SWIGTYPE_p_HOM_Volume, own);
584 case HOM_primType::VDB_Id:
585 return SWIG_NewPointerObj(
586 (
void*)dynamic_cast<const HOM_VDB* const>(prim),
587 SWIGTYPE_p_HOM_VDB, own);
589 case HOM_primType::ChannelPrim_Id:
590 return SWIG_NewPointerObj(
591 (
void*)dynamic_cast<const HOM_ChannelPrim* const>(prim),
592 SWIGTYPE_p_HOM_ChannelPrim, own);
597 return SWIG_NewPointerObj(prim, SWIGTYPE_p_HOM_Prim, own);
600 template <> InterpreterObject
601 HOMconvertValueForInterpreter<HOM_ParmTemplate*>(
605 return SWIG_NewPointerObj(
606 parm_template, SWIGTYPE_p_HOM_ParmTemplate, own);
611 switch (parm_template->type().id())
613 case HOM_parmTemplateType::Int_Id:
614 return SWIG_NewPointerObj(
615 (
void*)dynamic_cast<const HOM_IntParmTemplate* const>(
617 SWIGTYPE_p_HOM_IntParmTemplate, own);
619 case HOM_parmTemplateType::Float_Id:
620 return SWIG_NewPointerObj(
621 (
void*)dynamic_cast<const HOM_FloatParmTemplate* const>(
623 SWIGTYPE_p_HOM_FloatParmTemplate, own);
625 case HOM_parmTemplateType::String_Id:
626 return SWIG_NewPointerObj(
627 (
void*)dynamic_cast<const HOM_StringParmTemplate* const>(
629 SWIGTYPE_p_HOM_StringParmTemplate, own);
631 case HOM_parmTemplateType::Data_Id:
632 return SWIG_NewPointerObj(
633 (
void*)dynamic_cast<const HOM_DataParmTemplate* const>(
635 SWIGTYPE_p_HOM_DataParmTemplate, own);
637 case HOM_parmTemplateType::Toggle_Id:
638 return SWIG_NewPointerObj(
639 (
void*)dynamic_cast<const HOM_ToggleParmTemplate* const>(
641 SWIGTYPE_p_HOM_ToggleParmTemplate, own);
643 case HOM_parmTemplateType::Menu_Id:
644 return SWIG_NewPointerObj(
645 (
void*)dynamic_cast<const HOM_MenuParmTemplate* const>(
647 SWIGTYPE_p_HOM_MenuParmTemplate, own);
649 case HOM_parmTemplateType::Button_Id:
650 return SWIG_NewPointerObj(
651 (
void*)dynamic_cast<const HOM_ButtonParmTemplate* const>(
653 SWIGTYPE_p_HOM_ButtonParmTemplate, own);
655 case HOM_parmTemplateType::Label_Id:
656 return SWIG_NewPointerObj(
657 (
void*)dynamic_cast<const HOM_LabelParmTemplate* const>(
659 SWIGTYPE_p_HOM_LabelParmTemplate, own);
661 case HOM_parmTemplateType::Separator_Id:
662 return SWIG_NewPointerObj(
663 (
void*)dynamic_cast<const HOM_SeparatorParmTemplate* const>(
665 SWIGTYPE_p_HOM_SeparatorParmTemplate, own);
667 case HOM_parmTemplateType::FolderSet_Id:
668 return SWIG_NewPointerObj(
669 (
void*)dynamic_cast<const HOM_FolderSetParmTemplate* const>(
671 SWIGTYPE_p_HOM_FolderSetParmTemplate, own);
673 case HOM_parmTemplateType::Folder_Id:
674 return SWIG_NewPointerObj(
675 (
void*)dynamic_cast<const HOM_FolderParmTemplate* const>(
677 SWIGTYPE_p_HOM_FolderParmTemplate, own);
679 case HOM_parmTemplateType::Ramp_Id:
680 return SWIG_NewPointerObj(
681 (
void*)dynamic_cast<const HOM_RampParmTemplate* const>(
683 SWIGTYPE_p_HOM_RampParmTemplate, own);
686 UT_ASSERT(!
"Unknown parm template type");
687 return SWIG_NewPointerObj(parm_template, SWIGTYPE_p_HOM_ParmTemplate, own);
690 template <> InterpreterObject
691 HOMconvertValueForInterpreter<HOM_PaneTab*>(
695 return SWIG_NewPointerObj(pane_tab, SWIGTYPE_p_HOM_PaneTab, own);
701 switch (pane_tab->type().id())
703 case HOM_paneTabType::ContextViewer_Id:
704 return SWIG_NewPointerObj(
705 (
void*)dynamic_cast<const HOM_ContextViewer* const>(pane_tab),
706 SWIGTYPE_p_HOM_ContextViewer, own);
708 case HOM_paneTabType::SceneViewer_Id:
709 return SWIG_NewPointerObj(
710 (
void*)dynamic_cast<const HOM_SceneViewer* const>(pane_tab),
711 SWIGTYPE_p_HOM_SceneViewer, own);
713 case HOM_paneTabType::CompositorViewer_Id:
714 return SWIG_NewPointerObj(
715 (
void*)dynamic_cast<const HOM_CompositorViewer* const>(pane_tab),
716 SWIGTYPE_p_HOM_CompositorViewer, own);
718 case HOM_paneTabType::NetworkEditor_Id:
719 case HOM_paneTabType::ApexEditor_Id:
720 return SWIG_NewPointerObj(
721 (
void*)dynamic_cast<const HOM_NetworkEditor* const>(pane_tab),
722 SWIGTYPE_p_HOM_NetworkEditor, own);
724 case HOM_paneTabType::HelpBrowser_Id:
725 return SWIG_NewPointerObj(
726 (
void*)dynamic_cast<const HOM_HelpBrowser* const>(pane_tab),
727 SWIGTYPE_p_HOM_HelpBrowser, own);
729 case HOM_paneTabType::PythonPanel_Id:
730 return SWIG_NewPointerObj(
731 (
void*)dynamic_cast<const HOM_PythonPanel* const>(pane_tab),
732 SWIGTYPE_p_HOM_PythonPanel, own);
734 case HOM_paneTabType::IPRViewer_Id:
735 return SWIG_NewPointerObj(
736 (
void*)dynamic_cast<const HOM_IPRViewer* const>(pane_tab),
737 SWIGTYPE_p_HOM_IPRViewer, own);
739 case HOM_paneTabType::AssetBrowser_Id:
740 return SWIG_NewPointerObj(
741 (
void*)dynamic_cast<const HOM_AssetBrowser* const>(pane_tab),
742 SWIGTYPE_p_HOM_AssetBrowser, own);
744 case HOM_paneTabType::PerformanceMonitor_Id:
745 return SWIG_NewPointerObj(
746 (
void*)dynamic_cast<const HOM_PerformanceMonitor* const>(pane_tab),
747 SWIGTYPE_p_HOM_PerformanceMonitor, own);
749 case HOM_paneTabType::ChannelEditor_Id:
750 return SWIG_NewPointerObj(
751 (
void*)dynamic_cast<const HOM_ChannelEditorPane* const>(pane_tab),
752 SWIGTYPE_p_HOM_ChannelEditorPane, own);
754 case HOM_paneTabType::DataTree_Id:
755 return SWIG_NewPointerObj(
756 (
void*)dynamic_cast<const HOM_DataTree* const>(pane_tab),
757 SWIGTYPE_p_HOM_DataTree, own);
759 case HOM_paneTabType::SceneGraphTree_Id:
760 return SWIG_NewPointerObj(
761 (
void*)dynamic_cast<const HOM_SceneGraphTree* const>(pane_tab),
762 SWIGTYPE_p_HOM_SceneGraphTree, own);
764 case HOM_paneTabType::Parm_Id:
765 return SWIG_NewPointerObj(
766 (
void*)dynamic_cast<const HOM_ParameterEditor* const>(pane_tab),
767 SWIGTYPE_p_HOM_ParameterEditor, own);
769 case HOM_paneTabType::DetailsView_Id:
770 return SWIG_NewPointerObj(
771 (
void*)dynamic_cast<const HOM_GeometrySpreadsheet * const>(pane_tab),
772 SWIGTYPE_p_HOM_GeometrySpreadsheet, own);
774 case HOM_paneTabType::RenderGallery_Id:
775 return SWIG_NewPointerObj(
776 (
void*)dynamic_cast<const HOM_RenderGallery* const>(pane_tab),
777 SWIGTYPE_p_HOM_RenderGallery, own);
779 case HOM_paneTabType::ChannelViewer_Id:
780 case HOM_paneTabType::OutputViewer_Id:
781 case HOM_paneTabType::ShaderViewer_Id:
782 case HOM_paneTabType::TreeView_Id:
783 return SWIG_NewPointerObj(
784 (
void*)dynamic_cast<const HOM_PathBasedPaneTab* const>(pane_tab),
785 SWIGTYPE_p_HOM_PathBasedPaneTab, own);
787 case HOM_paneTabType::ChannelList_Id:
788 case HOM_paneTabType::Textport_Id:
789 case HOM_paneTabType::PythonShell_Id:
790 case HOM_paneTabType::HandleList_Id:
791 case HOM_paneTabType::BundleList_Id:
792 case HOM_paneTabType::TakeList_Id:
793 case HOM_paneTabType::ParmSpreadsheet_Id:
794 case HOM_paneTabType::LightLinker_Id:
795 case HOM_paneTabType::MaterialPalette_Id:
796 case HOM_paneTabType::EngineSessionSync_Id:
797 return SWIG_NewPointerObj(pane_tab, SWIGTYPE_p_HOM_PaneTab, own);
801 return SWIG_NewPointerObj(pane_tab, SWIGTYPE_p_HOM_PaneTab, own);
804 template <> InterpreterObject
805 HOMconvertValueForInterpreter<HOM_OpVerb*>(
809 return SWIG_NewPointerObj(opverb, SWIGTYPE_p_HOM_OpVerb, own);
818 return SWIG_NewPointerObj(
819 (
void*)dynamic_cast<HOM_CopVerb* const>(opverb),
820 SWIGTYPE_p_HOM_CopVerb, own);
826 return SWIG_NewPointerObj(
827 (
void*)dynamic_cast<HOM_SopVerb* const>(opverb),
828 SWIGTYPE_p_HOM_SopVerb, own);
834 return SWIG_NewPointerObj(opverb,
835 SWIGTYPE_p_HOM_OpVerb, own);
839 template <> InterpreterObject
840 HOMconvertValueForInterpreter<HOM_CopVerb*>(
843 return SWIG_NewPointerObj(verb, SWIGTYPE_p_HOM_CopVerb, own);
846 template <> InterpreterObject
847 HOMconvertValueForInterpreter<HOM_SopVerb*>(
850 return SWIG_NewPointerObj(verb, SWIGTYPE_p_HOM_SopVerb, own);
853 template <> InterpreterObject
854 HOMconvertValueForInterpreter<HOM_Geometry*>(
857 return SWIG_NewPointerObj(geo, SWIGTYPE_p_HOM_Geometry, own);
860 template <> InterpreterObject
861 HOMconvertValueForInterpreter<HOM_ImageLayer*>(
864 return SWIG_NewPointerObj(layer, SWIGTYPE_p_HOM_ImageLayer, own);
867 template <> InterpreterObject
868 HOMconvertValueForInterpreter<HOM_NanoVDB*>(
871 return SWIG_NewPointerObj(layer, SWIGTYPE_p_HOM_NanoVDB, own);
874 template <> InterpreterObject
875 HOMconvertValueForInterpreter<HOM_NetworkItem*>(
883 switch (item->networkItemType().id())
885 case HOM_networkItemType::Node_Id:
886 return HOMconvertValueForInterpreter(
887 dynamic_cast<HOM_Node* const>(item), own);
889 case HOM_networkItemType::NetworkBox_Id:
890 return HOMconvertValueForInterpreter(
891 dynamic_cast<HOM_NetworkBox* const>(item), own);
893 case HOM_networkItemType::StickyNote_Id:
894 return HOMconvertValueForInterpreter(
895 dynamic_cast<HOM_StickyNote* const>(item), own);
897 case HOM_networkItemType::SubnetIndirectInput_Id:
898 return HOMconvertValueForInterpreter(
899 dynamic_cast<HOM_SubnetIndirectInput* const>(item), own);
901 case HOM_networkItemType::Connection_Id:
902 return HOMconvertValueForInterpreter(
903 dynamic_cast<HOM_NodeConnection* const>(item), own);
905 case HOM_networkItemType::NetworkDot_Id:
906 return HOMconvertValueForInterpreter(
907 dynamic_cast<HOM_NetworkDot* const>(item), own);
914 return SWIG_NewPointerObj(item, SWIGTYPE_p_HOM_NetworkItem, own);
917 template <> InterpreterObject
918 HOMconvertValueForInterpreter<HOM_NetworkMovableItem*>(
922 return SWIG_NewPointerObj(item, SWIGTYPE_p_HOM_NetworkMovableItem, own);
924 return HOMconvertValueForInterpreter<HOM_NetworkItem *>(item, own);
927 template <> InterpreterObject
928 HOMconvertValueForInterpreter<
929 std::vector<HOM_ElemPtr<HOM_NodeConnection> >*>(
930 std::vector<HOM_ElemPtr<HOM_NodeConnection> > *
const &list,
933 return swig::from(*list);
936 template <> InterpreterObject
937 HOMconvertValueForInterpreter<HOM_DopData*>(
HOM_DopData *
const &
data,
int own)
942 return SWIG_NewPointerObj(
943 (
void *)dop_object, SWIGTYPE_p_HOM_DopObject, own);
947 if (dop_relationship)
948 return SWIG_NewPointerObj(
949 (
void *)dop_relationship, SWIGTYPE_p_HOM_DopRelationship, own);
951 return SWIG_NewPointerObj(data, SWIGTYPE_p_HOM_DopData, own);
954 template <> InterpreterObject
955 HOMconvertValueForInterpreter<HOM_RadialItem*>(
960 switch (item->type().id())
962 case HOM_radialItemType::Script_Id:
963 return SWIG_NewPointerObj(
964 (
void*)dynamic_cast<const HOM_RadialScriptItem* const>(item),
965 SWIGTYPE_p_HOM_RadialScriptItem, own);
967 case HOM_radialItemType::Submenu_Id:
968 return SWIG_NewPointerObj(
969 (
void*)dynamic_cast<const HOM_RadialSubmenu* const>(item),
970 SWIGTYPE_p_HOM_RadialSubmenu, own);
977 return SWIG_NewPointerObj(item, SWIGTYPE_p_HOM_RadialItem, own);
980 template <> InterpreterObject
981 HOMconvertValueForInterpreter<HOM_EnumValue*>(
989 return SWIG_NewPointerObj((
void*)item, SWIGTYPE_p_HOM_EnumValue, 0);
994 #define HOM_PROVIDE_SWIG_LOOKUP(type) \
995 template <> InterpreterObject HOMconvertValueForInterpreter<type*>( \
996 type* const& value, int own) \
998 return SWIG_NewPointerObj(SWIG_as_voidptr(value), \
999 SWIGTYPE_p_ ## type, own); \
1094 #define HOM_CONVERT_AND_CATCH \
1097 $result = HOMconvertValueForInterpreter($1, $owner); \
1101 (void)hom::raise_swig_exception(); \
1102 $result = nullptr; \
1107 HOM_CONVERT_AND_CATCH
1111 HOM_CONVERT_AND_CATCH
1115 HOM_CONVERT_AND_CATCH
1119 HOM_CONVERT_AND_CATCH
1123 HOM_CONVERT_AND_CATCH
1127 HOM_CONVERT_AND_CATCH
1131 HOM_CONVERT_AND_CATCH
1135 HOM_CONVERT_AND_CATCH
1139 HOM_CONVERT_AND_CATCH
1143 HOM_CONVERT_AND_CATCH
1147 HOM_CONVERT_AND_CATCH
1151 HOM_CONVERT_AND_CATCH
1155 HOM_CONVERT_AND_CATCH
1159 HOM_CONVERT_AND_CATCH
1163 HOM_CONVERT_AND_CATCH
1167 HOM_CONVERT_AND_CATCH
1171 HOM_CONVERT_AND_CATCH
1175 HOM_CONVERT_AND_CATCH
1179 HOM_CONVERT_AND_CATCH
1183 HOM_CONVERT_AND_CATCH
1187 HOM_CONVERT_AND_CATCH
1194 %typemap(
throws) HOM_TypeError %{
1195 SWIG_exception_fail(SWIG_TypeError, $1.instanceMessage().
c_str());
1198 %typemap(
throws) HOM_ValueError %{
1199 SWIG_exception_fail(SWIG_ValueError, $1.instanceMessage().
c_str());
1204 PyErr_SetObject(PyExc_SystemExit, SWIG_From_int($1.code()));
1214 %typemap(
in) hboost::
any {
1219 HOMinterpreterObjectToBoostAny($input, $1);
1223 (
void)hom::raise_swig_exception();
1235 HOMinterpreterObjectToUTOptionAny($input, $1);
1239 (
void)hom::raise_swig_exception();
1244 %typemap(out) hboost::any {
1247 $result = HOMboostAnyToInterpreterObject($1);
1251 (
void)hom::raise_swig_exception();
1258 $result = HOMDDSourceAnyToInterpreterObject($1);
1262 (
void)hom::raise_swig_exception();
1272 if ($input != Py_None)
1276 if (SWIG_IsOK(SWIG_AsVal_double($input, &res)))
1284 (
void)hom::raise_swig_exception();
1292 if ($input != Py_None)
1296 if (SWIG_IsOK(SWIG_AsVal_int($input, &res)))
1304 (
void)hom::raise_swig_exception();
1308 %typemap(out) HOM_OptionalInt {
1312 $result = SWIG_From_int($1.
value());
1314 $result = SWIG_Py_Void();
1318 (
void)hom::raise_swig_exception();
1326 $result = HOMincRef((InterpreterObject)$1.opaqueObject());
1336 struct traits_from<PY_OpaqueObject>
1338 static PyObject *from(
const PY_OpaqueObject &
val)
1340 return HOMincRef((InterpreterObject)val.
opaqueObject());
1346 template <
typename T>
1349 swig_type_info *descriptor)
1352 int res = SWIG_ConvertPtr(input, &t_ptr, descriptor, 0);;
1353 if (SWIG_IsOK(res) && t_ptr)
1356 result =
reinterpret_cast<T*
>(t_ptr);
1367 template <
typename Seq,
typename T =
typename Seq::value_type>
1369 HOMinterpreterObjectConvertSeq(InterpreterObject input,
hboost::any &result)
1371 swig::SwigPySequence_Cont<T> swigpyseq(input);
1372 if (!swigpyseq.check())
1375 auto n = swigpyseq.size();
1378 for (
auto i=0;i<
n; ++i)
1379 seq[i] = swigpyseq[i];
1381 result = std::move(seq);
1386 template <
typename T>
1388 HOMinterpreterObjectConvertVal(InterpreterObject input,
hboost::any &result)
1393 swig_type_info *descriptor = swig::type_info<T>();
1398 int res = SWIG_ConvertPtr(input, (
void**)&t_ptr, descriptor, 0);
1400 if (!SWIG_IsOK(res) || !t_ptr)
1408 result = std::move(*t_ptr);
1409 if (SWIG_IsNewObj(res))
1415 template <
typename T>
1417 HOMinterpreterObjectConvertAsPtr(InterpreterObject input,
hboost::any &result)
1421 int res = swig::asptr(input, (T**)NULL);
1422 if (!SWIG_IsOK(res))
1427 res = swig::asptr(input, &t_ptr);
1428 if (!SWIG_IsOK(res) || !t_ptr)
1436 result = std::move(*t_ptr);
1437 if (SWIG_IsNewObj(res))
1443 #define CONVERT_PTR(X) \
1444 if (HOMinterpreterObjectConvertPtr<X>(\
1445 swig_input,result,SWIGTYPE_p_##X))\
1448 #define CONVERT_VAL(X) \
1449 if (HOMinterpreterObjectConvertVal<X>(swig_input,result))\
1452 #define CONVERT_ASPTR(X) \
1453 if (HOMinterpreterObjectConvertAsPtr<X>(input,result))\
1456 #define CONVERT_SEQ(X) \
1457 if (HOMinterpreterObjectConvertSeq<X>(input,result))\
1461 typedef std::map<std::string,hboost::any> std__map_std__string_hboost__any_;
1462 typedef std::vector<std::map<std::string,hboost::any>> std__vector_std__map_std__string_hboost__any__;
1471 HOMinterpreterObjectToBoostAny(InterpreterObject input,
hboost::any &result)
1474 if (input == Py_None)
1476 result = (
void *)NULL;
1482 if (input == Py_True)
1488 if (input == Py_False)
1496 if (SWIG_IsOK(SWIG_AsVal_int(input, &int_result)))
1498 result = int_result;
1502 double double_result;
1503 if (SWIG_IsOK(SWIG_AsVal_double(input, &double_result)))
1505 result = double_result;
1510 char*
buf = 0 ;
size_t size = 0;
int alloc = SWIG_OLDOBJ;
1511 if (SWIG_IsOK((SWIG_AsCharPtrAndSize(input, &buf, &size, &alloc))))
1515 result = std::string(buf, size - 1);
1516 if (alloc == SWIG_NEWOBJ)
1521 result = std::string();
1531 bool is_seq = PyList_Check(input) || PyTuple_Check(input);
1532 bool is_dict = PyDict_Check(input);
1535 CONVERT_SEQ(std::vector<int>);
1536 CONVERT_SEQ(std::vector<double>);
1537 CONVERT_SEQ(std::vector<std::string>);
1538 CONVERT_SEQ(std::vector<HOM_Quaternion>);
1539 CONVERT_SEQ(std::vector<HOM_Vector2>);
1540 CONVERT_SEQ(std::vector<HOM_Vector3>);
1541 CONVERT_SEQ(std::vector<HOM_Vector4>);
1542 CONVERT_SEQ(std::vector<HOM_Matrix2>);
1543 CONVERT_SEQ(std::vector<HOM_Matrix3>);
1544 CONVERT_SEQ(std::vector<HOM_Matrix4>);
1545 CONVERT_SEQ(std__vector_std__map_std__string_hboost__any__);
1549 CONVERT_ASPTR(std__map_std__string_hboost__any_);
1556 InterpreterObject swig_input =
1557 (InterpreterObject)SWIG_Python_GetSwigThis(input);
1559 CONVERT_VAL(std::string);
1577 CONVERT_VAL(std::vector<int>);
1578 CONVERT_VAL(std::vector<double>);
1579 CONVERT_VAL(std::vector<std::string>);
1580 CONVERT_VAL(std::vector<HOM_Quaternion>);
1581 CONVERT_VAL(std::vector<HOM_Vector2>);
1582 CONVERT_VAL(std::vector<HOM_Vector3>);
1583 CONVERT_VAL(std::vector<HOM_Vector4>);
1584 CONVERT_VAL(std::vector<HOM_Matrix2>);
1585 CONVERT_VAL(std::vector<HOM_Matrix3>);
1586 CONVERT_VAL(std::vector<HOM_Matrix4>);
1587 CONVERT_VAL(std__map_std__string_hboost__any_);
1588 CONVERT_VAL(std__vector_std__map_std__string_hboost__any__);
1601 HOMinterpreterObjectToUTOptionAny(InterpreterObject input,
1602 HOM_UTOptionAny &result)
1604 return HOMinterpreterObjectToBoostAny(input, result);
1612 struct traits_asptr<hboost::any>
1618 HOMinterpreterObjectToBoostAny(obj, *p);
1633 static InterpreterObject
1634 HOMboostAnyToInterpreterObject(
const hboost::any &result)
1637 return SWIG_Py_Void();
1639 namespace ti = hboost::typeindex;
1641 if (result.type() == ti::type_id<int>())
1642 return SWIG_From_int(hboost::any_cast<int>(result));
1644 if (result.type() == ti::type_id<long>())
1645 return SWIG_From_long(hboost::any_cast<long>(result));
1647 if (result.type() == ti::type_id<int64>())
1648 return swig::from(hboost::any_cast<int64>(result));
1650 if (result.type() == ti::type_id<float>())
1651 return SWIG_From_float(hboost::any_cast<float>(result));
1653 if (result.type() == ti::type_id<double>())
1654 return SWIG_From_double(hboost::any_cast<double>(result));
1656 if (result.type() == ti::type_id<bool>())
1657 return SWIG_From_bool(hboost::any_cast<bool>(result));
1659 if (result.type() == ti::type_id<std::string>())
1660 return SWIG_From_std_string(hboost::any_cast<std::string>(result));
1662 if (result.type() == ti::type_id<HOM_BinaryString>())
1663 return SWIG_From_HOM_BinaryString(hboost::any_cast<HOM_BinaryString>(result));
1665 if (result.type() == ti::type_id<std::map<std::string, hboost::any>>())
1667 hboost::any_cast<std::map<std::string, hboost::any> >(result));
1669 if (result.type() == ti::type_id<std::vector<int>>())
1670 return swig::from(hboost::any_cast<std::vector<int> >(result));
1672 if (result.type() == ti::type_id<std::vector<int64>>())
1673 return swig::from(hboost::any_cast<std::vector<int64> >(result));
1675 if (result.type() == ti::type_id<std::vector<float>>())
1676 return swig::from(hboost::any_cast<std::vector<float> >(result));
1678 if (result.type() == ti::type_id<std::vector<std::string>>())
1679 return swig::from(hboost::any_cast<std::vector<std::string> >(result));
1681 if (result.type() == ti::type_id<std::vector<double>>())
1682 return swig::from(hboost::any_cast<std::vector<double> >(result));
1684 if (result.type() == ti::type_id<std::vector<std::vector<float> >>())
1686 hboost::any_cast<std::vector<std::vector<float> > >(result));
1688 if (result.type() == ti::type_id<std::vector<std::vector<double> >>())
1690 hboost::any_cast<std::vector<std::vector<double> > >(result));
1692 if (result.type() == ti::type_id<std::vector<std::map<std::string, hboost::any> >>())
1694 hboost::any_cast<std::vector<std::map<std::string, hboost::any> > >(result));
1698 if (result.type() == ti::type_id<HOM_Vector2 *>())
1699 return HOMconvertValueForInterpreter(
1700 hboost::any_cast<HOM_Vector2 *>(result), SWIG_POINTER_OWN);
1702 if (result.type() == ti::type_id<HOM_Vector3 *>())
1703 return HOMconvertValueForInterpreter(
1704 hboost::any_cast<HOM_Vector3 *>(result), SWIG_POINTER_OWN);
1706 if (result.type() == ti::type_id<HOM_Vector4 *>())
1707 return HOMconvertValueForInterpreter(
1708 hboost::any_cast<HOM_Vector4 *>(result), SWIG_POINTER_OWN);
1710 if (result.type() == ti::type_id<HOM_Matrix2 *>())
1711 return HOMconvertValueForInterpreter(
1712 hboost::any_cast<HOM_Matrix2 *>(result), SWIG_POINTER_OWN);
1714 if (result.type() == ti::type_id<HOM_Matrix3 *>())
1715 return HOMconvertValueForInterpreter(
1716 hboost::any_cast<HOM_Matrix3 *>(result), SWIG_POINTER_OWN);
1718 if (result.type() == ti::type_id<HOM_Matrix4 *>())
1719 return HOMconvertValueForInterpreter(
1720 hboost::any_cast<HOM_Matrix4 *>(result), SWIG_POINTER_OWN);
1722 if (result.type() == ti::type_id<HOM_Quaternion *>())
1723 return HOMconvertValueForInterpreter(
1724 hboost::any_cast<HOM_Quaternion *>(result), SWIG_POINTER_OWN);
1726 if (result.type() == ti::type_id<HOM_NodeType *>())
1727 return HOMconvertValueForInterpreter(
1728 hboost::any_cast<HOM_NodeType *>(result), SWIG_POINTER_OWN);
1730 if (result.type() == ti::type_id<HOM_Ramp *>())
1731 return HOMconvertValueForInterpreter(
1732 hboost::any_cast<HOM_Ramp *>(result), SWIG_POINTER_OWN);
1734 if (result.type() == ti::type_id<HOM_Color *>())
1735 return HOMconvertValueForInterpreter(
1736 hboost::any_cast<HOM_Color *>(result), SWIG_POINTER_OWN);
1738 if (result.type() == ti::type_id<HOM_Parm *>())
1739 return HOMconvertValueForInterpreter(
1740 hboost::any_cast<HOM_Parm *>(result), SWIG_POINTER_OWN);
1742 if (result.type() == ti::type_id<HOM_EnumValue *>())
1743 return HOMconvertValueForInterpreter(
1744 hboost::any_cast<HOM_EnumValue *>(result), 0);
1746 if (result.type() == ti::type_id<HOM_Geometry *>())
1747 return HOMconvertValueForInterpreter(
1748 hboost::any_cast<HOM_Geometry *>(result), SWIG_POINTER_OWN);
1750 if (result.type() == ti::type_id<HOM_ImageLayer *>())
1751 return HOMconvertValueForInterpreter(
1752 hboost::any_cast<HOM_ImageLayer *>(result), SWIG_POINTER_OWN);
1754 if (result.type() == ti::type_id<HOM_NanoVDB *>())
1755 return HOMconvertValueForInterpreter(
1756 hboost::any_cast<HOM_NanoVDB *>(result), SWIG_POINTER_OWN);
1758 if (result.type() == ti::type_id<std::vector<HOM_ElemPtr<HOM_Vector2> >>())
1762 if (result.type() == ti::type_id<std::vector<HOM_ElemPtr<HOM_Vector3> >>())
1766 if (result.type() == ti::type_id<std::vector<HOM_ElemPtr<HOM_Vector4> >>())
1770 if (result.type() == ti::type_id<std::vector<HOM_ElemPtr<HOM_Matrix2> >>())
1774 if (result.type() == ti::type_id<std::vector<HOM_ElemPtr<HOM_Matrix3> >>())
1778 if (result.type() == ti::type_id<std::vector<HOM_ElemPtr<HOM_Matrix4> >>())
1782 if (result.type() == ti::type_id<std::vector<HOM_ElemPtr<HOM_Quaternion> >>())
1786 #if UT_ASSERT_LEVEL > 0
1787 std::cout <<
"Unknown data type: "
1791 return SWIG_Py_Void();
1796 static InterpreterObject
1797 HOMDDSourceAnyToInterpreterObject(
const HOM_DDSourceAny &result)
1799 namespace ti = hboost::typeindex;
1801 if (result.type() == ti::type_id<HOM_Node *>())
1803 return HOMconvertValueForInterpreter(
1804 hboost::any_cast<HOM_Node *>(result), SWIG_POINTER_OWN);
1806 if (result.type() == ti::type_id<HOM_Parm *>())
1808 return HOMconvertValueForInterpreter(
1809 hboost::any_cast<HOM_Parm *>(result), SWIG_POINTER_OWN);
1811 if (result.type() == ti::type_id<HOM_GalleryEntry *>())
1813 return HOMconvertValueForInterpreter(
1814 hboost::any_cast<HOM_GalleryEntry *>(result), SWIG_POINTER_OWN);
1817 return HOMboostAnyToInterpreterObject(result);
1824 struct traits_from<hboost::any>
1827 {
return HOMboostAnyToInterpreterObject(val); }
1831 static InterpreterObject
1832 HOMoptionsToInterpreterObject(
const UT_Options &options);
1834 static InterpreterObject
1835 HOMoptionEntryToInterpreterObject(
const UT_OptionEntry &option_entry)
1841 InterpreterObject result = NULL;
1843 switch (option_entry.
getType())
1850 return SWIG_From_bool(
1854 return SWIG_From_double(
1860 return SWIG_From_std_string(
1865 return HOMconvertValueForInterpreter(
1871 return HOMconvertValueForInterpreter(
1877 return HOMconvertValueForInterpreter(
1883 return HOMconvertValueForInterpreter(
1889 return HOMconvertValueForInterpreter(
1895 return HOMconvertValueForInterpreter(
1901 return HOMconvertValueForInterpreter(
1907 return HOMconvertValueForInterpreter(
1913 return HOMconvertValueForInterpreter(
1920 std::vector<int64> int_vector;
1922 static_cast<const UT_OptionInt64Array &>(option_entry)
1924 return swig::from(int_vector);
1929 std::vector<double> double_vector;
1931 static_cast<const UT_OptionFpreal64Array &>(option_entry)
1933 return swig::from(double_vector);
1938 std::vector<std::string> str_vector;
1939 UTarrayToStdVectorOfStrings(
1940 static_cast<const UT_OptionStringArray &>(option_entry)
1942 return swig::from(str_vector);
1949 return HOMoptionsToInterpreterObject(*opt.
options());
1955 InterpreterObject result = PyList_New(0);
1957 for (
auto && opt : optlist)
1959 PyList_Append(result, HOMoptionsToInterpreterObject(*opt.
options()));
1970 return result ? result : SWIG_Py_Void();
1974 static InterpreterObject
1975 HOMoptionsToInterpreterObject(
const UT_Options &options)
1981 InterpreterObject result = PyDict_New();
1987 InterpreterObject value=HOMoptionEntryToInterpreterObject(*it.entry());
1988 PyDict_SetItemString(result, it.name(),
value);
1995 static InterpreterObject
1996 HOMoptionsListToInterpreterObject(
const std::vector<UT_Options>& options)
1998 auto pysize = options.size();
2004 InterpreterObject list = PyList_New(pysize);
2005 for (
int i = 0; i < pysize; ++i)
2007 auto value = HOMoptionsToInterpreterObject(options[i]);
2009 PyList_SET_ITEM(list, i, value);
2020 template<
typename T>
2021 PyObject* HOMgetattr(T* hom_object,
const char *
name)
2029 PyObject *dict = context
2032 ? PyDict_GetItemString(dict, name) : NULL;
2035 if (!attribute && dict)
2038 attribute = name ? PyDict_GetItemString(dict, name) : NULL;
2044 return HOMincRef(attribute);
2050 error_message.
sprintf(
"'module' object has no attribute '%s'", name);
2051 PyErr_SetString(PyExc_AttributeError, error_message.
buffer());
2065 HOM_PyBuffer(InterpreterObject py_object)
2067 #if PY_VERSION_HEX >= 0x03000000
2068 myBytesObj =
nullptr;
2073 PyObject *obj = py_object;
2075 #if PY_VERSION_HEX >= 0x03000000
2077 if (PyUnicode_Check(obj))
2080 PyUnicode_AsEncodedString(obj,
"utf-8",
"surrogateescape");
2086 #if PY_VERSION_HEX >= 0x02060000
2087 myUseNewAPI =
false;
2088 if (PyObject_CheckBuffer(obj))
2090 if (PyObject_GetBuffer(obj, &myPyBuffer, PyBUF_SIMPLE) < 0)
2092 #if PY_VERSION_HEX >= 0x03000000
2093 cleanBytesObject_();
2095 throw HOM_TypeError(
"failed to get readable buffer");
2099 myData = myPyBuffer.buf;
2100 myLength = myPyBuffer.len;
2105 #if PY_VERSION_HEX >= 0x03000000
2106 cleanBytesObject_();
2107 throw HOM_TypeError(
"failed to get readable buffer");
2111 if (!PyObject_CheckReadBuffer(obj))
2112 throw HOM_TypeError(
"expected a readable buffer");
2114 if (PyObject_AsReadBuffer(obj, &myData, &myLength) < 0)
2115 throw HOM_TypeError(
"failed to get readable buffer");
2121 #if PY_VERSION_HEX >= 0x03000000
2122 cleanBytesObject_();
2125 #if PY_VERSION_HEX >= 0x02060000
2127 PyBuffer_Release(&myPyBuffer);
2131 #if PY_VERSION_HEX >= 0x03000000
2132 void cleanBytesObject_()
2137 Py_DECREF(myBytesObj);
2138 myBytesObj =
nullptr;
2142 #if PY_VERSION_HEX >= 0x03000000
2143 PyObject *myBytesObj;
2146 #if PY_VERSION_HEX >= 0x02060000
2148 Py_buffer myPyBuffer;
2151 Py_ssize_t myLength;
2161 template <
typename T,
typename A>
2163 HOMattribValue(T &geo_element,
A &hom_attrib,
2169 InterpreterObject result = NULL;
2170 const bool scalar = (attr_size == 1 && !is_array_type);
2171 switch (array_data_type)
2173 case HOM_attribData::Int_Id:
2175 result = swig::from(
2176 hboost::any_cast<int64>(geo_element.intAttribValue(hom_attrib)));
2178 result = swig::from(
2179 hboost::any_cast<std::vector<int64> >(
2180 geo_element.intListAttribValue(hom_attrib)));
2183 case HOM_attribData::Float_Id:
2185 result = SWIG_From_double(geo_element.floatAttribValue(hom_attrib));
2187 result = swig::from(geo_element.floatListAttribValue(hom_attrib));
2190 case HOM_attribData::String_Id:
2192 result = SWIG_From_std_string(
2193 geo_element.stringAttribValue(hom_attrib));
2195 result = swig::from(geo_element.stringListAttribValue(hom_attrib));
2198 case HOM_attribData::Dict_Id:
2200 result = swig::from(geo_element.dictAttribValue(hom_attrib));
2202 result = swig::from(geo_element.dictListAttribValue(hom_attrib));
2209 template <
typename T>
2211 HOMattribValue(T &geo_element,
HOM_Attrib &hom_attrib)
2213 return HOMattribValue(geo_element,
2220 template <
typename T>
2222 HOMattribValue(T &geo_element,
const char *name)
2225 bool is_array_type =
false;
2226 int attr_data_type = 0;
2227 geo_element._attribInfo(name,attr_data_type,attr_size,is_array_type);
2228 return HOMattribValue(geo_element,name, attr_size, is_array_type,
2237 static InterpreterObject
2242 case HOM_parmData::Int_Id:
2243 return swig::from(hboost::any_cast<int64>(parm.
evalAsInt()));
2244 case HOM_parmData::Float_Id:
2246 case HOM_parmData::String_Id:
2248 case HOM_parmData::Ramp_Id:
2249 return SWIG_NewPointerObj(
2250 (
void*)parm.
evalAsRamp(), SWIGTYPE_p_HOM_Ramp, SWIG_POINTER_OWN);
2251 case HOM_parmData::Data_Id:
2255 return SWIG_NewPointerObj(
2256 (
void*)parm.
evalAsGeometry(), SWIGTYPE_p_HOM_Geometry, SWIG_POINTER_OWN);
2260 return SWIG_Py_Void();
2263 static InterpreterObject
2264 HOMevalParmAtFrame(
HOM_Parm &parm,
double frame)
2268 case HOM_parmData::Int_Id:
2270 case HOM_parmData::Float_Id:
2272 case HOM_parmData::String_Id:
2274 case HOM_parmData::Ramp_Id:
2275 return SWIG_NewPointerObj(
2277 SWIGTYPE_p_HOM_Ramp, SWIG_POINTER_OWN);
2278 case HOM_parmData::Data_Id:
2282 return SWIG_NewPointerObj(
2284 SWIGTYPE_p_HOM_Geometry, SWIG_POINTER_OWN);
2288 return SWIG_Py_Void();
2291 static InterpreterObject
2296 case HOM_parmData::Int_Id:
2298 case HOM_parmData::Float_Id:
2300 case HOM_parmData::String_Id:
2302 case HOM_parmData::Ramp_Id:
2304 case HOM_parmData::Data_Id:
2306 == HOM_dataParmType::KeyValueDictionary_Id)
2315 return SWIG_Py_Void();
2318 static InterpreterObject
2319 HOMevalParmTupleAtFrame(
HOM_ParmTuple &parm_tuple,
double frame)
2323 case HOM_parmData::Int_Id:
2325 case HOM_parmData::Float_Id:
2327 case HOM_parmData::String_Id:
2329 case HOM_parmData::Ramp_Id:
2331 case HOM_parmData::Data_Id:
2333 == HOM_dataParmType::KeyValueDictionary_Id)
2342 return SWIG_Py_Void();
2345 static InterpreterObject
2350 case HOM_parmData::Int_Id:
2351 return swig::from(hboost::any_cast<int64>(visualizer.
evalParmAsInt(parm_name)));
2352 case HOM_parmData::Float_Id:
2354 case HOM_parmData::String_Id:
2356 case HOM_parmData::Ramp_Id:
2357 return SWIG_NewPointerObj(
2358 (
void*)visualizer.
evalParmAsRamp(parm_name), SWIGTYPE_p_HOM_Ramp,
2363 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 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
constexpr auto in(type t, int set) -> bool
__hostdev__ float getValue(uint32_t i) const
std::optional< T > UT_Optional
virtual HOM_Ramp * evalParmAsRamp(const char *parm_name)=0
GLenum GLuint GLint GLint layer
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 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
virtual int64 evalAsInt()=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 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
OIIO_UTIL_API const char * c_str(string_view str)
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 int64 evalAsIntAtFrame(double frame)=0
virtual HOM_Geometry * evalAsGeometry()=0