shader_bsdf.h

/******************************************************************************
 * Copyright 1986, 2015 NVIDIA ARC GmbH. All rights reserved.
 ******************************************************************************
 * Created:     14.06.2013
 * Purpose:     BSDF interface for mental ray
 *
 * Note: This file is generated automatically from the mental ray sources, do
 * not edit. Some definitions exist for internal reasons and are subject to
 * change between mental ray versions. See the mental ray user's manual for
 * a definitive description of the shader interface. Avoid using features not
 * documented in the manual because they may change in future versions.
 *****************************************************************************/

#ifndef SHADER_BSDF_H
#define SHADER_BSDF_H


/*------------ brdf.h ------------*/


namespace mi {
namespace shader_v3 {


class Bsdf
{
public:
    // no virtual dtor

    typedef bool Transport;
    static const Transport From_eye     = false;  
    static const Transport From_light   = true;   

    enum {
        // single types
        Invalid           = 0x00, 
        Reflect_diffuse   = 0x01, 
        Reflect_glossy    = 0x02, 
        Reflect_specular  = 0x04, 
        Transmit_diffuse  = 0x10, 
        Transmit_glossy   = 0x20, 
        Transmit_specular = 0x40, 
        
        // compound types
        Reflect_regular           
        = Reflect_diffuse
        | Reflect_glossy,
        Transmit_regular          
        = Transmit_diffuse
        | Transmit_glossy,
        All_diffuse               
        = Reflect_diffuse 
        | Transmit_diffuse,
        All_glossy                
        = Reflect_glossy 
        | Transmit_glossy,
        All_specular              
        = Reflect_specular 
        | Transmit_specular,
        All_regular               
        = Reflect_regular 
        | Transmit_regular,
        All_reflect               
        = Reflect_regular 
        | Reflect_specular,
        All_transmit              
        = Transmit_regular 
        | Transmit_specular,
        All                       
        = All_reflect 
        | All_transmit
    };
    typedef miUint4 Type;

    
    virtual miColor eval(
            const miVector&     ray,
            const miVector&     out,
            Type                flags = All,
            Transport           dir = From_eye
            ) const = 0;
    

    virtual Type sample(
            const miVector&     ray,
            miVector*           out,
            miColor*            weight,
            double              xi[3],
            Type                flags = All,
            Transport           dir = From_eye
            ) const = 0;
    
    virtual bool all_components(Type type) const = 0;


    virtual bool any_component(Type type) const = 0;
    
    
    virtual Type get_components() const = 0;
};

class Access_bsdf
{
public:
    
    Access_bsdf(miState* state)
    : m_state(state)
    {
        m_bsdf = Access_interface()->allocBsdf(state);
    }

    
    Access_bsdf()
    : m_state(0), m_bsdf(0)
    {}
    
    
    ~Access_bsdf()
    {
        Access_interface()->releaseBsdf(m_bsdf,m_state);
    }
    
    
    const Bsdf* operator->() const { return m_bsdf; }
    
    
    bool valid() const { return 0 != m_bsdf; }


    void reset(miState* state = 0)
    {
        Access_interface()->releaseBsdf(m_bsdf,m_state);
        m_state = state;
        m_bsdf = state ? Access_interface()->allocBsdf(state) : 0;
    }


private:
    Access_bsdf(const Access_bsdf&);
    Access_bsdf& operator=(const Access_bsdf&);
    
    miState*    m_state;
    Bsdf*       m_bsdf;
};

}}


#endif