MDL SDK API nvidia_logo_transpbg.gif Up
 All Classes Namespaces Files Functions Variables Typedefs Enumerations Enumerator Friends Groups Pages
definition_wrapper.h
Go to the documentation of this file.
1 /***************************************************************************************************
2  * Copyright 2022 NVIDIA Corporation. All rights reserved.
3  **************************************************************************************************/
6 
7 #ifndef MI_NEURAYLIB_DEFINITION_WRAPPER_H
8 #define MI_NEURAYLIB_DEFINITION_WRAPPER_H
9 
10 #include <mi/base/handle.h>
11 #include <mi/neuraylib/assert.h>
19 #include <mi/neuraylib/itype.h>
20 #include <mi/neuraylib/ivalue.h>
21 
22 #include <string>
23 
24 namespace mi {
25 
26 namespace neuraylib {
27 
32 class Definition_wrapper
46 {
47 public:
48 
50 
51 
59  Definition_wrapper( ITransaction* transaction, const char* name, IMdl_factory* mdl_factory);
60 
66  bool is_valid() const;
67 
76  bool is_valid_definition( IMdl_execution_context* context) const;
77 
86  Element_type get_type() const;
87 
89  const char* get_mdl_definition() const;
90 
92  const char* get_module() const;
93 
95  bool is_exported() const;
96 
98  bool is_material() const;
99 
101  Size get_parameter_count() const;
102 
107  const char* get_parameter_name( Size index) const;
108 
113  Size get_parameter_index( const char* name) const;
114 
116  const IType_list* get_parameter_types() const;
117 
119  const IType* get_return_type() const;
120 
128  const char* get_thumbnail() const;
129 
130 
132 
134 
140  const IExpression_list* get_defaults() const;
141 
159  template<class T>
160  Sint32 get_default( Size index, T& value) const;
161 
175  template <class T>
176  Sint32 get_default( const char* name, T& value) const;
177 
179 
181 
183  const IAnnotation_block* get_annotations() const;
184 
191  const IAnnotation_list* get_parameter_annotations() const;
192 
194  const IAnnotation_block* get_return_annotations() const;
195 
202  const IExpression_list* get_enable_if_conditions() const;
203 
210  Size get_enable_if_users( Size index) const;
211 
219  Size get_enable_if_user( Size index, Size u_index) const;
220 
222 
224 
248  IScene_element* create_instance(
249  const IExpression_list* arguments = 0, Sint32* errors = 0) const;
250 
277  template <class T>
278  T* create_instance( const IExpression_list* arguments = 0, Sint32* errors = 0) const
279  {
280  IScene_element* ptr_iscene_element = create_instance( arguments, errors);
281  if( !ptr_iscene_element)
282  return 0;
283  T* ptr_T = static_cast<T*>( ptr_iscene_element->get_interface( typename T::IID()));
284  ptr_iscene_element->release();
285  return ptr_T;
286  }
287 
289 
291 
293  ITransaction* get_transaction() const;
294 
296  IMdl_factory* get_mdl_factory() const;
297 
299  const IScene_element* get_scene_element() const;
300 
303 
305  const std::string& get_name() const;
306 
308 
309 private:
310 
311  base::Handle<ITransaction> m_transaction;
313  base::Handle<IMdl_factory> m_mdl_factory;
314  Element_type m_type;
315  std::string m_name;
316 };
317  // end group mi_neuray_mdl_elements
319 
321  ITransaction* transaction, const char* name, IMdl_factory* mdl_factory)
322 {
323  mi_neuray_assert( transaction);
324  mi_neuray_assert( name);
325 
326  m_transaction = make_handle_dup( transaction);
327  m_name = name;
328  m_mdl_factory = make_handle_dup( mdl_factory);
329  m_access = transaction->access<IScene_element>( name);
330  m_type = m_access ? m_access->get_element_type() : static_cast<Element_type>( 0);
331 }
332 
333 inline bool Definition_wrapper::is_valid() const
334 {
335  return m_access
337  || m_type == ELEMENT_TYPE_FUNCTION_DEFINITION);
338 }
339 
340 
342 {
343  if( m_type == ELEMENT_TYPE_MATERIAL_DEFINITION) {
344 
346  m_access->get_interface<IMaterial_definition>());
347  return md->is_valid( context);
348  }
349  else if( m_type == ELEMENT_TYPE_FUNCTION_DEFINITION) {
350 
352  m_access->get_interface<IFunction_definition>());
353  return fd->is_valid( context);
354  }
355  else
356  return false;
357 }
358 
360 {
361  return m_type;
362 }
363 
364 inline const char* Definition_wrapper::get_mdl_definition() const
365 {
366  if( m_type == ELEMENT_TYPE_MATERIAL_DEFINITION) {
367 
369  m_access->get_interface<IMaterial_definition>());
370  return md->get_mdl_name();
371 
372  } else if( m_type == ELEMENT_TYPE_FUNCTION_DEFINITION) {
373 
375  m_access->get_interface<IFunction_definition>());
376  return fd->get_mdl_name();
377 
378  } else
379  return 0;
380 }
381 
382 inline const char* Definition_wrapper::get_module() const
383 {
384  if( m_type == ELEMENT_TYPE_MATERIAL_DEFINITION) {
385 
387  m_access->get_interface<IMaterial_definition>());
388  return md->get_module();
389 
390  } else if( m_type == ELEMENT_TYPE_FUNCTION_DEFINITION) {
391 
393  m_access->get_interface<IFunction_definition>());
394  return fd->get_module();
395 
396  } else
397  return 0;
398 }
399 
401 {
402  if( m_type == ELEMENT_TYPE_MATERIAL_DEFINITION) {
403 
405  m_access->get_interface<IMaterial_definition>());
406  return md->is_exported();
407 
408  } else if( m_type == ELEMENT_TYPE_FUNCTION_DEFINITION) {
409 
411  m_access->get_interface<IFunction_definition>());
412  return fd->is_exported();
413 
414  } else
415  return false;
416 }
417 
419 {
420  if( !m_access)
421  return false;
422 
424  m_access->get_interface<IMaterial_definition>());
425  return md.is_valid_interface();
426 }
427 
429 {
430  if( m_type == ELEMENT_TYPE_MATERIAL_DEFINITION) {
431 
433  m_access->get_interface<IMaterial_definition>());
434  return md->get_parameter_count();
435 
436  } else if( m_type == ELEMENT_TYPE_FUNCTION_DEFINITION) {
437 
439  m_access->get_interface<IFunction_definition>());
440  return fd->get_parameter_count();
441 
442  } else
443  return 0;
444 }
445 
446 inline const char* Definition_wrapper::get_parameter_name( Size index) const
447 {
448  if( m_type == ELEMENT_TYPE_MATERIAL_DEFINITION) {
449 
451  m_access->get_interface<IMaterial_definition>());
452  return md->get_parameter_name( index);
453 
454  } else if( m_type == ELEMENT_TYPE_FUNCTION_DEFINITION) {
455 
457  m_access->get_interface<IFunction_definition>());
458  return fd->get_parameter_name( index);
459 
460  } else
461  return 0;
462 }
463 
464 inline Size Definition_wrapper::get_parameter_index( const char* name) const
465 {
466  if( m_type == ELEMENT_TYPE_MATERIAL_DEFINITION) {
467 
469  m_access->get_interface<IMaterial_definition>());
470  return md->get_parameter_index( name);
471 
472  } else if( m_type == ELEMENT_TYPE_FUNCTION_DEFINITION) {
473 
475  m_access->get_interface<IFunction_definition>());
476  return fd->get_parameter_index( name);
477 
478  } else
479  return 0;
480 }
481 
483 {
484  if( m_type == ELEMENT_TYPE_MATERIAL_DEFINITION) {
485 
487  m_access->get_interface<IMaterial_definition>());
488  return md->get_parameter_types();
489 
490  } else if( m_type == ELEMENT_TYPE_FUNCTION_DEFINITION) {
491 
493  m_access->get_interface<IFunction_definition>());
494  return fd->get_parameter_types();
495 
496  } else
497  return 0;
498 }
499 
501 {
502  if( m_type == ELEMENT_TYPE_MATERIAL_DEFINITION) {
503 
504  return 0;
505 
506  } else if( m_type == ELEMENT_TYPE_FUNCTION_DEFINITION) {
507 
509  m_access->get_interface<IFunction_definition>());
510  return fd->get_return_type();
511 
512  } else
513  return 0;
514 }
515 
516 inline const char* Definition_wrapper::get_thumbnail() const
517 {
518  if( m_type == ELEMENT_TYPE_MATERIAL_DEFINITION) {
519 
521  m_access->get_interface<IMaterial_definition>());
522  return md->get_thumbnail();
523 
524  }
525  else if( m_type == ELEMENT_TYPE_FUNCTION_DEFINITION) {
526 
528  m_access->get_interface<IFunction_definition>());
529  return fd->get_thumbnail();
530 
531  }
532  else
533  return 0;
534 }
535 
537 {
538  if( m_type == ELEMENT_TYPE_MATERIAL_DEFINITION) {
539 
541  m_access->get_interface<IMaterial_definition>());
542  return md->get_defaults();
543 
544  } else if( m_type == ELEMENT_TYPE_FUNCTION_DEFINITION) {
545 
547  m_access->get_interface<IFunction_definition>());
548  return fd->get_defaults();
549 
550  } else
551  return 0;
552 }
553 
554 template <class T>
556 {
557  if( m_type == ELEMENT_TYPE_MATERIAL_DEFINITION) {
558 
560  m_access->get_interface<IMaterial_definition>());
561  base::Handle<const IExpression_list> defaults( md->get_defaults());
562  base::Handle<const IExpression> default_( defaults->get_expression( index));
563  if( !default_)
564  return -2;
566  default_->get_interface<IExpression_constant>());
567  if( !default_constant)
568  return -4;
569  base::Handle<const IValue> default_value( default_constant->get_value());
570  Sint32 result = get_value( default_value.get(), value);
571  return result == 0 ? 0 : -5;
572 
573  } else if( m_type == ELEMENT_TYPE_FUNCTION_DEFINITION) {
574 
576  m_access->get_interface<IFunction_definition>());
577  base::Handle<const IExpression_list> defaults( fd->get_defaults());
578  base::Handle<const IExpression> default_( defaults->get_expression( index));
579  if( !default_)
580  return -2;
582  default_->get_interface<IExpression_constant>());
583  if( !default_constant)
584  return -4;
585  base::Handle<const IValue> default_value( default_constant->get_value());
586  Sint32 result = get_value( default_value.get(), value);
587  return result == 0 ? 0 : -5;
588 
589  } else
590  return -1;
591 }
592 
593 template <class T>
594 Sint32 Definition_wrapper::get_default( const char* name, T& value) const
595 {
596  if( m_type == ELEMENT_TYPE_MATERIAL_DEFINITION) {
597 
599  m_access->get_interface<IMaterial_definition>());
600  base::Handle<const IExpression_list> defaults( md->get_defaults());
601  base::Handle<const IExpression> default_( defaults->get_expression( name));
602  if( !default_)
603  return -2;
605  default_->get_interface<IExpression_constant>());
606  if( !default_constant)
607  return -4;
608  base::Handle<const IValue> default_value( default_constant->get_value());
609  Sint32 result = get_value( default_value.get(), value);
610  return result == 0 ? 0 : -5;
611 
612  } else if( m_type == ELEMENT_TYPE_FUNCTION_DEFINITION) {
613 
615  m_access->get_interface<IFunction_definition>());
616  base::Handle<const IExpression_list> defaults( fd->get_defaults());
617  base::Handle<const IExpression> default_( defaults->get_expression( name));
618  if( !default_)
619  return -2;
621  default_->get_interface<IExpression_constant>());
622  if( !default_constant)
623  return -4;
624  base::Handle<const IValue> default_value( default_constant->get_value());
625  Sint32 result = get_value( default_value.get(), value);
626  return result == 0 ? 0 : -5;
627 
628  } else
629  return -1;
630 }
631 
633 {
634  if( m_type == ELEMENT_TYPE_MATERIAL_DEFINITION) {
635 
637  m_access->get_interface<IMaterial_definition>());
638  return md->get_annotations();
639 
640  } else if( m_type == ELEMENT_TYPE_FUNCTION_DEFINITION) {
641 
643  m_access->get_interface<IFunction_definition>());
644  return fd->get_annotations();
645 
646  } else
647  return 0;
648 }
649 
651 {
652  if( m_type == ELEMENT_TYPE_MATERIAL_DEFINITION) {
653 
655  m_access->get_interface<IMaterial_definition>());
656  return md->get_parameter_annotations();
657 
658  } else if( m_type == ELEMENT_TYPE_FUNCTION_DEFINITION) {
659 
661  m_access->get_interface<IFunction_definition>());
662  return fd->get_parameter_annotations();
663 
664  } else
665  return 0;
666 }
667 
669 {
670  if( m_type == ELEMENT_TYPE_MATERIAL_DEFINITION) {
671 
673  m_access->get_interface<IMaterial_definition>());
674  return md->get_return_annotations();
675 
676  } else if( m_type == ELEMENT_TYPE_FUNCTION_DEFINITION) {
677 
679  m_access->get_interface<IFunction_definition>());
680  return fd->get_return_annotations();
681 
682  } else
683  return 0;
684 }
685 
687 {
688  if( m_type == ELEMENT_TYPE_MATERIAL_DEFINITION) {
689 
691  m_access->get_interface<IMaterial_definition>());
692  return md->get_enable_if_conditions();
693 
694  }
695  else if( m_type == ELEMENT_TYPE_FUNCTION_DEFINITION) {
696 
698  m_access->get_interface<IFunction_definition>());
699  return fd->get_enable_if_conditions();
700 
701  } else
702  return 0;
703 }
704 
706 {
707  if( m_type == ELEMENT_TYPE_MATERIAL_DEFINITION) {
708 
710  m_access->get_interface<IMaterial_definition>());
711  return md->get_enable_if_users( index);
712 
713  }
714  else if( m_type == ELEMENT_TYPE_FUNCTION_DEFINITION) {
715 
717  m_access->get_interface<IFunction_definition>());
718  return fd->get_enable_if_users( index);
719 
720  } else
721  return Size(~0);
722 }
723 
725 {
726  if( m_type == ELEMENT_TYPE_MATERIAL_DEFINITION) {
727 
729  m_access->get_interface<IMaterial_definition>());
730  return md->get_enable_if_user( index, u_index);
731 
732  }
733  else if( m_type == ELEMENT_TYPE_FUNCTION_DEFINITION) {
734 
736  m_access->get_interface<IFunction_definition>());
737  return fd->get_enable_if_user( index, u_index);
738 
739  } else
740  return Size(~0);
741 }
742 
744  const IExpression_list* arguments, Sint32* errors) const
745 {
746  if( m_type == ELEMENT_TYPE_MATERIAL_DEFINITION) {
747 
749  m_access->get_interface<IMaterial_definition>());
750  if( arguments)
751  return md->create_material_instance( arguments, errors);
752 
753  base::Handle<const IType_list> parameter_types( md->get_parameter_types());
754  base::Handle<const IExpression_list> defaults( md->get_defaults());
755  base::Handle<const IAnnotation_list> parameter_annotations(
756  md->get_parameter_annotations());
757  base::Handle<IValue_factory> vf( m_mdl_factory->create_value_factory( m_transaction.get()));
759  m_mdl_factory->create_expression_factory( m_transaction.get()));
760  base::Handle<IExpression_list> local_arguments( ef->create_expression_list());
761 
762  Size count = md->get_parameter_count();
763  for( Size i = 0; i < count; ++i) {
764  const char* name = md->get_parameter_name( i);
765  base::Handle<const IExpression> default_( defaults->get_expression( name));
766  if( !default_) {
767  base::Handle<const IType> type( parameter_types->get_type( i));
769  parameter_annotations->get_annotation_block( name));
770  base::Handle<IValue> value( vf->create( type.get(), block.get()));
771  base::Handle<IExpression> expr( ef->create_constant( value.get()));
772  local_arguments->add_expression( name, expr.get());
773  }
774  }
775  return md->create_material_instance( local_arguments.get(), errors);
776 
777  } else if( m_type == ELEMENT_TYPE_FUNCTION_DEFINITION) {
778 
780  m_access->get_interface<IFunction_definition>());
781  if( arguments)
782  return fd->create_function_call( arguments, errors);
783 
784  IFunction_definition::Semantics semantic = fd->get_semantic();
788  || semantic == IFunction_definition::DS_TERNARY
789  || semantic == IFunction_definition::DS_CAST) {
790  if( errors)
791  *errors = -4;
792  return 0;
793  }
794 
795  base::Handle<const IType_list> parameter_types( fd->get_parameter_types());
796  base::Handle<const IExpression_list> defaults( fd->get_defaults());
797  base::Handle<const IAnnotation_list> parameter_annotations(
798  fd->get_parameter_annotations());
799  base::Handle<IValue_factory> vf( m_mdl_factory->create_value_factory( m_transaction.get()));
801  m_mdl_factory->create_expression_factory( m_transaction.get()));
802  base::Handle<IExpression_list> local_arguments( ef->create_expression_list());
803 
804  Size count = fd->get_parameter_count();
805  for( Size i = 0; i < count; ++i) {
806  const char* name = fd->get_parameter_name( i);
807  base::Handle<const IExpression> default_( defaults->get_expression( name));
808  if( !default_) {
809  base::Handle<const IType> type( parameter_types->get_type( i));
811  parameter_annotations->get_annotation_block( name));
812  base::Handle<IValue> value( vf->create( type.get(), block.get()));
813  base::Handle<IExpression> expr( ef->create_constant( value.get()));
814  local_arguments->add_expression( name, expr.get());
815  }
816  }
817  return fd->create_function_call( local_arguments.get(), errors);
818 
819  } else
820  return 0;
821 }
822 
824 {
825  m_transaction->retain();
826  return m_transaction.get();
827 }
828 
830 {
831  m_mdl_factory->retain();
832  return m_mdl_factory.get();
833 }
834 
836 {
837  m_access->retain();
838  return m_access.get();
839 }
840 
842 {
843  return m_type;
844 }
845 
846 inline const std::string& Definition_wrapper::get_name() const
847 {
848  return m_name;
849 }
850 
851 } // namespace neuraylib
852 
853 } // namespace mi
854 
855 #endif // MI_NEURAYLIB_DEFINITION_WRAPPER_H