Material Definition Language 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 2020 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
43 {
44 public:
45 
47 
48 
56  Definition_wrapper( ITransaction* transaction, const char* name, IMdl_factory* mdl_factory);
57 
63  bool is_valid() const;
64 
73  bool is_valid_definition(IMdl_execution_context* context) const;
74 
81  Element_type get_type() const;
82 
84  const char* get_mdl_definition() const;
85 
87  const char* get_module() const;
88 
90  bool is_exported() const;
91 
93  Size get_parameter_count() const;
94 
99  const char* get_parameter_name( Size index) const;
100 
105  Size get_parameter_index( const char* name) const;
106 
108  const IType_list* get_parameter_types() const;
109 
113  const IType* get_return_type() const;
114 
122  const char* get_thumbnail() const;
123 
124 
126 
128 
134  const IExpression_list* get_defaults() const;
135 
153  template<class T>
154  Sint32 get_default( Size index, T& value) const;
155 
169  template <class T>
170  Sint32 get_default( const char* name, T& value) const;
171 
173 
175 
177  const IAnnotation_block* get_annotations() const;
178 
185  const IAnnotation_list* get_parameter_annotations() const;
186 
191  const IAnnotation_block* get_return_annotations() const;
192 
199  const IExpression_list* get_enable_if_conditions() const;
200 
207  Size get_enable_if_users( Size index) const;
208 
216  Size get_enable_if_user( Size index, Size u_index) const;
217 
219 
221 
240  IScene_element* create_instance(
241  const IExpression_list* arguments = 0, Sint32* errors = 0) const;
242 
264  template <class T>
265  T* create_instance( const IExpression_list* arguments = 0, Sint32* errors = 0) const
266  {
267  IScene_element* ptr_iscene_element = create_instance( arguments, errors);
268  if ( !ptr_iscene_element)
269  return 0;
270  T* ptr_T = static_cast<T*>( ptr_iscene_element->get_interface( typename T::IID()));
271  ptr_iscene_element->release();
272  return ptr_T;
273  }
274 
276 
278 
280  ITransaction* get_transaction() const;
281 
283  IMdl_factory* get_mdl_factory() const;
284 
286  const IScene_element* get_scene_element() const;
287 
290 
292  const std::string& get_name() const;
293 
295 
296 private:
297 
298  base::Handle<ITransaction> m_transaction;
300  base::Handle<IMdl_factory> m_mdl_factory;
301  Element_type m_type;
302  std::string m_name;
303 };
304  // end group mi_neuray_mdl_elements
306 
308  ITransaction* transaction, const char* name, IMdl_factory* mdl_factory)
309 {
310  mi_neuray_assert( transaction);
311  mi_neuray_assert( name);
312 
313  m_transaction = make_handle_dup( transaction);
314  m_name = name;
315  m_mdl_factory = make_handle_dup( mdl_factory);
316  m_access = transaction->access<IScene_element>( name);
317  m_type = m_access ? m_access->get_element_type() : static_cast<Element_type>( 0);
318 }
319 
320 inline bool Definition_wrapper::is_valid() const
321 {
322  return m_access
324  || m_type == ELEMENT_TYPE_FUNCTION_DEFINITION);
325 }
326 
327 
329 {
330  if (m_type == ELEMENT_TYPE_MATERIAL_DEFINITION) {
331 
332  base::Handle<const IMaterial_definition> md(m_access->get_interface<IMaterial_definition>());
333  return md->is_valid(context);
334  }
335  else if (m_type == ELEMENT_TYPE_FUNCTION_DEFINITION) {
336 
337  base::Handle<const IFunction_definition> fd(m_access->get_interface<IFunction_definition>());
338  return fd->is_valid(context);
339  }
340  else
341  return false;
342 }
343 
345 {
346  return m_type;
347 }
348 
349 inline const char* Definition_wrapper::get_mdl_definition() const
350 {
351  if( m_type == ELEMENT_TYPE_MATERIAL_DEFINITION) {
352 
354  m_access->get_interface<IMaterial_definition>());
355  return md->get_mdl_name();
356 
357  } else if( m_type == ELEMENT_TYPE_FUNCTION_DEFINITION) {
358 
360  m_access->get_interface<IFunction_definition>());
361  return fd->get_mdl_name();
362 
363  } else
364  return 0;
365 }
366 
367 inline const char* Definition_wrapper::get_module() const
368 {
369  if( m_type == ELEMENT_TYPE_MATERIAL_DEFINITION) {
370 
372  m_access->get_interface<IMaterial_definition>());
373  return md->get_module();
374 
375  } else if( m_type == ELEMENT_TYPE_FUNCTION_DEFINITION) {
376 
378  m_access->get_interface<IFunction_definition>());
379  return fd->get_module();
380 
381  } else
382  return 0;
383 }
384 
386 {
387  if( m_type == ELEMENT_TYPE_MATERIAL_DEFINITION) {
388 
390  m_access->get_interface<IMaterial_definition>());
391  return md->is_exported();
392 
393  } else if( m_type == ELEMENT_TYPE_FUNCTION_DEFINITION) {
394 
396  m_access->get_interface<IFunction_definition>());
397  return fd->is_exported();
398 
399  } else
400  return false;
401 }
402 
404 {
405  if( m_type == ELEMENT_TYPE_MATERIAL_DEFINITION) {
406 
408  m_access->get_interface<IMaterial_definition>());
409  return md->get_parameter_count();
410 
411  } else if( m_type == ELEMENT_TYPE_FUNCTION_DEFINITION) {
412 
414  m_access->get_interface<IFunction_definition>());
415  return fd->get_parameter_count();
416 
417  } else
418  return 0;
419 }
420 
421 inline const char* Definition_wrapper::get_parameter_name( Size index) const
422 {
423  if( m_type == ELEMENT_TYPE_MATERIAL_DEFINITION) {
424 
426  m_access->get_interface<IMaterial_definition>());
427  return md->get_parameter_name( index);
428 
429  } else if( m_type == ELEMENT_TYPE_FUNCTION_DEFINITION) {
430 
432  m_access->get_interface<IFunction_definition>());
433  return fd->get_parameter_name( index);
434 
435  } else
436  return 0;
437 }
438 
439 inline Size Definition_wrapper::get_parameter_index( const char* name) const
440 {
441  if( m_type == ELEMENT_TYPE_MATERIAL_DEFINITION) {
442 
444  m_access->get_interface<IMaterial_definition>());
445  return md->get_parameter_index( name);
446 
447  } else if( m_type == ELEMENT_TYPE_FUNCTION_DEFINITION) {
448 
450  m_access->get_interface<IFunction_definition>());
451  return fd->get_parameter_index( name);
452 
453  } else
454  return 0;
455 }
456 
458 {
459  if( m_type == ELEMENT_TYPE_MATERIAL_DEFINITION) {
460 
462  m_access->get_interface<IMaterial_definition>());
463  return md->get_parameter_types();
464 
465  } else if( m_type == ELEMENT_TYPE_FUNCTION_DEFINITION) {
466 
468  m_access->get_interface<IFunction_definition>());
469  return fd->get_parameter_types();
470 
471  } else
472  return 0;
473 }
474 
476 {
477  if( m_type == ELEMENT_TYPE_MATERIAL_DEFINITION) {
478 
479  return 0;
480 
481  } else if( m_type == ELEMENT_TYPE_FUNCTION_DEFINITION) {
482 
484  m_access->get_interface<IFunction_definition>());
485  return fd->get_return_type();
486 
487  } else
488  return 0;
489 }
490 
491 inline const char* Definition_wrapper::get_thumbnail() const
492 {
493  if (m_type == ELEMENT_TYPE_MATERIAL_DEFINITION) {
494 
496  m_access->get_interface<IMaterial_definition>());
497  return md->get_thumbnail();
498 
499  }
500  else if (m_type == ELEMENT_TYPE_FUNCTION_DEFINITION) {
501 
503  m_access->get_interface<IFunction_definition>());
504  return fd->get_thumbnail();
505 
506  }
507  else
508  return 0;
509 }
510 
512 {
513  if( m_type == ELEMENT_TYPE_MATERIAL_DEFINITION) {
514 
516  m_access->get_interface<IMaterial_definition>());
517  return md->get_defaults();
518 
519  } else if( m_type == ELEMENT_TYPE_FUNCTION_DEFINITION) {
520 
522  m_access->get_interface<IFunction_definition>());
523  return fd->get_defaults();
524 
525  } else
526  return 0;
527 }
528 
529 template <class T>
531 {
532  if( m_type == ELEMENT_TYPE_MATERIAL_DEFINITION) {
533 
535  m_access->get_interface<IMaterial_definition>());
536  base::Handle<const IExpression_list> defaults( md->get_defaults());
537  base::Handle<const IExpression> default_( defaults->get_expression( index));
538  if( !default_)
539  return -2;
541  default_->get_interface<IExpression_constant>());
542  if( !default_constant)
543  return -4;
544  base::Handle<const IValue> default_value( default_constant->get_value());
545  Sint32 result = get_value( default_value.get(), value);
546  return result == 0 ? 0 : -5;
547 
548  } else if( m_type == ELEMENT_TYPE_FUNCTION_DEFINITION) {
549 
551  m_access->get_interface<IFunction_definition>());
552  base::Handle<const IExpression_list> defaults( fd->get_defaults());
553  base::Handle<const IExpression> default_( defaults->get_expression( index));
554  if( !default_)
555  return -2;
557  default_->get_interface<IExpression_constant>());
558  if( !default_constant)
559  return -4;
560  base::Handle<const IValue> default_value( default_constant->get_value());
561  Sint32 result = get_value( default_value.get(), value);
562  return result == 0 ? 0 : -5;
563 
564  } else
565  return -1;
566 }
567 
568 template <class T>
569 Sint32 Definition_wrapper::get_default( const char* name, T& value) const
570 {
571  if( m_type == ELEMENT_TYPE_MATERIAL_DEFINITION) {
572 
574  m_access->get_interface<IMaterial_definition>());
575  base::Handle<const IExpression_list> defaults( md->get_defaults());
576  base::Handle<const IExpression> default_( defaults->get_expression( name));
577  if( !default_)
578  return -2;
580  default_->get_interface<IExpression_constant>());
581  if( !default_constant)
582  return -4;
583  base::Handle<const IValue> default_value( default_constant->get_value());
584  Sint32 result = get_value( default_value.get(), value);
585  return result == 0 ? 0 : -5;
586 
587  } else if( m_type == ELEMENT_TYPE_FUNCTION_DEFINITION) {
588 
590  m_access->get_interface<IFunction_definition>());
591  base::Handle<const IExpression_list> defaults( fd->get_defaults());
592  base::Handle<const IExpression> default_( defaults->get_expression( name));
593  if( !default_)
594  return -2;
596  default_->get_interface<IExpression_constant>());
597  if( !default_constant)
598  return -4;
599  base::Handle<const IValue> default_value( default_constant->get_value());
600  Sint32 result = get_value( default_value.get(), value);
601  return result == 0 ? 0 : -5;
602 
603  } else
604  return -1;
605 }
606 
608 {
609  if( m_type == ELEMENT_TYPE_MATERIAL_DEFINITION) {
610 
612  m_access->get_interface<IMaterial_definition>());
613  return md->get_annotations();
614 
615  } else if( m_type == ELEMENT_TYPE_FUNCTION_DEFINITION) {
616 
618  m_access->get_interface<IFunction_definition>());
619  return fd->get_annotations();
620 
621  } else
622  return 0;
623 }
624 
626 {
627  if( m_type == ELEMENT_TYPE_MATERIAL_DEFINITION) {
628 
630  m_access->get_interface<IMaterial_definition>());
631  return md->get_parameter_annotations();
632 
633  } else if( m_type == ELEMENT_TYPE_FUNCTION_DEFINITION) {
634 
636  m_access->get_interface<IFunction_definition>());
637  return fd->get_parameter_annotations();
638 
639  } else
640  return 0;
641 }
642 
644 {
645  if( m_type == ELEMENT_TYPE_MATERIAL_DEFINITION) {
646 
647  return 0;
648 
649  } else if( m_type == ELEMENT_TYPE_FUNCTION_DEFINITION) {
650 
652  m_access->get_interface<IFunction_definition>());
653  return fd->get_return_annotations();
654 
655  } else
656  return 0;
657 }
658 
660 {
661  if( m_type == ELEMENT_TYPE_MATERIAL_DEFINITION) {
662 
664  m_access->get_interface<IMaterial_definition>());
665  return md->get_enable_if_conditions();
666 
667  }
668  else if( m_type == ELEMENT_TYPE_FUNCTION_DEFINITION) {
669 
671  m_access->get_interface<IFunction_definition>());
672  return fd->get_enable_if_conditions();
673 
674  } else
675  return 0;
676 }
677 
679 {
680  if( m_type == ELEMENT_TYPE_MATERIAL_DEFINITION) {
681 
683  m_access->get_interface<IMaterial_definition>());
684  return md->get_enable_if_users( index);
685 
686  }
687  else if( m_type == ELEMENT_TYPE_FUNCTION_DEFINITION) {
688 
690  m_access->get_interface<IFunction_definition>());
691  return fd->get_enable_if_users( index);
692 
693  } else
694  return Size(~0);
695 }
696 
698 {
699  if( m_type == ELEMENT_TYPE_MATERIAL_DEFINITION) {
700 
702  m_access->get_interface<IMaterial_definition>());
703  return md->get_enable_if_user( index, u_index);
704 
705  }
706  else if( m_type == ELEMENT_TYPE_FUNCTION_DEFINITION) {
707 
709  m_access->get_interface<IFunction_definition>());
710  return fd->get_enable_if_user( index, u_index);
711 
712  } else
713  return Size(~0);
714 }
715 
717  const IExpression_list* arguments, Sint32* errors) const
718 {
719  if( m_type == ELEMENT_TYPE_MATERIAL_DEFINITION) {
720 
722  m_access->get_interface<IMaterial_definition>());
723  if( arguments)
724  return md->create_material_instance( arguments, errors);
725 
726  base::Handle<const IType_list> parameter_types( md->get_parameter_types());
727  base::Handle<const IExpression_list> defaults( md->get_defaults());
728  base::Handle<IValue_factory> vf( m_mdl_factory->create_value_factory( m_transaction.get()));
730  m_mdl_factory->create_expression_factory( m_transaction.get()));
731  base::Handle<IExpression_list> local_arguments( ef->create_expression_list());
732 
733  Size count = md->get_parameter_count();
734  for( Size i = 0; i < count; ++i) {
735  const char* name = md->get_parameter_name( i);
736  base::Handle<const IExpression> default_( defaults->get_expression( name));
737  if( !default_) {
738  base::Handle<const IType> type( parameter_types->get_type( i));
739  base::Handle<IValue> value( vf->create( type.get()));
740  base::Handle<IExpression> expr( ef->create_constant( value.get()));
741  local_arguments->add_expression( name, expr.get());
742  }
743  }
744  return md->create_material_instance( local_arguments.get(), errors);
745 
746  } else if( m_type == ELEMENT_TYPE_FUNCTION_DEFINITION) {
747 
749  m_access->get_interface<IFunction_definition>());
750  if( arguments)
751  return fd->create_function_call( arguments, errors);
752 
753  base::Handle<const IType_list> parameter_types( fd->get_parameter_types());
754  base::Handle<const IExpression_list> defaults( fd->get_defaults());
755  base::Handle<IValue_factory> vf( m_mdl_factory->create_value_factory( m_transaction.get()));
757  m_mdl_factory->create_expression_factory( m_transaction.get()));
758  base::Handle<IExpression_list> local_arguments( ef->create_expression_list());
759 
760  Size count = fd->get_parameter_count();
761  for( Size i = 0; i < count; ++i) {
762  const char* name = fd->get_parameter_name( i);
763  base::Handle<const IExpression> default_( defaults->get_expression( name));
764  if( !default_) {
765  base::Handle<const IType> type( parameter_types->get_type( i));
766  base::Handle<IValue> value( vf->create( type.get()));
767  base::Handle<IExpression> expr( ef->create_constant( value.get()));
768  local_arguments->add_expression( name, expr.get());
769  }
770  }
771  return fd->create_function_call( local_arguments.get(), errors);
772 
773  } else
774  return 0;
775 }
776 
778 {
779  m_transaction->retain();
780  return m_transaction.get();
781 }
782 
784 {
785  m_mdl_factory->retain();
786  return m_mdl_factory.get();
787 }
788 
790 {
791  m_access->retain();
792  return m_access.get();
793 }
794 
796 {
797  return m_type;
798 }
799 
801 {
802  return m_name;
803 }
804 
805 } // namespace neuraylib
806 
807 } // namespace mi
808 
809 #endif // MI_NEURAYLIB_DEFINITION_WRAPPER_H