ilight.h

Go to the documentation of this file.

 //*****************************************************************************


 // Copyright 1986, 2016 NVIDIA Corporation. All rights reserved.


 //*****************************************************************************


 //*****************************************************************************


 

 #ifndef MI_NEURAYLIB_ILIGHT_H


 #define MI_NEURAYLIB_ILIGHT_H


 


 #include <mi/neuraylib/iscene_element.h>


 #include <mi/neuraylib/version.h>


 

 namespace mi {

 

 namespace neuraylib {

 

 class IGroup;

 class MI_NEURAYLIB_DEPRECATED_CLASS_METASL(IShader);

 class MI_NEURAYLIB_DEPRECATED_CLASS_METASL(IShader_graph);

 

 enum Light_type {

     LIGHT_POINT       = 0,       

 #ifdef MI_NEURAYLIB_DEPRECATED_METASL


     LIGHT_SPOT        = 1,

 #endif // MI_NEURAYLIB_DEPRECATED_METASL


     LIGHT_INFINITE    = 2,       

 #ifdef MI_NEURAYLIB_DEPRECATED_METASL


     LIGHT_PLANAR      = 3,

 #endif // MI_NEURAYLIB_DEPRECATED_METASL


     N_LIGHT_TYPES,

     LIGHT_FORCE_32_BIT = 0xffffffffU

 };

 

 mi_static_assert( sizeof( Light_type) == sizeof( Uint32));

 

 enum Light_area_shape {

     AREA_NONE         = 0,       

     AREA_RECTANGLE    = 1,       

     AREA_DISC         = 2,       

     AREA_SPHERE       = 3,       

     AREA_CYLINDER     = 4,       

     N_AREA_TYPES,

     AREA_FORCE_32_BIT = 0xffffffffU

 };

 

 mi_static_assert( sizeof( Light_area_shape) == sizeof( Uint32));

 

 class ILight :

     public base::Interface_declare<0xc9a437cf,0x6d47,0x4666,0x9c,0xf6,0xa4,0x3f,0x50,0xe8,0x0b,0x90,

                                    neuraylib::IScene_element>

 {

 public:

     virtual Light_type get_type() const = 0;

 

     virtual void set_type(Light_type type) = 0;

 

     virtual Light_area_shape get_area_shape() const = 0;

 

     virtual void set_area_shape(Light_area_shape light_area_shape) = 0;

 

     virtual Float64 get_area_radius() const = 0;

 

     virtual void set_area_radius(Float64 radius) = 0;

 

     virtual Float64 get_area_size_x() const = 0;

 

     virtual void set_area_size_x(Float64 size_x) = 0;

 

     virtual Float64 get_area_size_y() const = 0;

 

     virtual void set_area_size_y(Float64 size_y) = 0;

 

     virtual Float64 MI_NEURAYLIB_DEPRECATED_METHOD_METASL(get_spread)() const = 0;

 

     virtual void MI_NEURAYLIB_DEPRECATED_METHOD_METASL(set_spread)(Float64 spread) = 0;

 

     virtual Float64 MI_NEURAYLIB_DEPRECATED_METHOD_METASL(get_distance)() const = 0;

 

     virtual void MI_NEURAYLIB_DEPRECATED_METHOD_METASL(set_distance)(Float64 distance) = 0;

 

     virtual Sint32 attach_light_definition( const char* name) = 0;

 

     virtual void detach_light_definition() = 0;

 

     virtual const MI_NEURAYLIB_DEPRECATED_CLASS_METASL(IShader_graph)*

         access_light_definition() const = 0;

 

     virtual MI_NEURAYLIB_DEPRECATED_CLASS_METASL(IShader_graph)*

         edit_light_definition() const = 0;

 

     virtual Sint32 MI_NEURAYLIB_DEPRECATED_METHOD_METASL(attach_shader)(

         Shader_type type, const char* name) = 0;

 

     virtual Sint32 MI_NEURAYLIB_DEPRECATED_METHOD_METASL(detach_shader)(

         Shader_type type) = 0;

 

     virtual const MI_NEURAYLIB_DEPRECATED_CLASS_METASL(IShader)*

         access_shader( Shader_type type) const = 0;

 

     virtual MI_NEURAYLIB_DEPRECATED_CLASS_METASL(IShader)*

         edit_shader( Shader_type type) const = 0;

 };

  // end group mi_neuray_leaf_nodes


 

 } // namespace neuraylib


 

 #ifdef MI_NEURAYLIB_DEPRECATED_NAMESPACE_MI_TRANSITION


 using neuraylib::AREA_CYLINDER;

 using neuraylib::AREA_DISC;

 using neuraylib::AREA_FORCE_32_BIT;

 using neuraylib::AREA_NONE;

 using neuraylib::AREA_RECTANGLE;

 using neuraylib::AREA_SPHERE;

 using neuraylib::IGroup;

 using neuraylib::ILight;

 using neuraylib::IScene_element;

 using neuraylib::MI_NEURAYLIB_DEPRECATED_CLASS_METASL(IShader);

 using neuraylib::MI_NEURAYLIB_DEPRECATED_CLASS_METASL(IShader_graph);

 using neuraylib::LIGHT_FORCE_32_BIT;

 using neuraylib::LIGHT_INFINITE;

 using neuraylib::LIGHT_PLANAR;

 using neuraylib::LIGHT_POINT;

 using neuraylib::LIGHT_SPOT;

 using neuraylib::Light_area_shape;

 using neuraylib::Light_type;

 using neuraylib::N_AREA_TYPES;

 using neuraylib::N_LIGHT_TYPES;

 using neuraylib::Shader_type;

 #endif // MI_NEURAYLIB_DEPRECATED_NAMESPACE_MI_TRANSITION


 


 } // namespace mi


 

 #endif // MI_NEURAYLIB_ILIGHT_H