shader_lightlist.h

Go to the documentation of this file.

// Copyright 1986, 2015 NVIDIA ARC GmbH. All rights reserved.
// Created:     27.02.08
// Module:      api
// Purpose:     mental ray C++ shader interface extensions



#ifndef SHADER_LIGHTLIST_H
#define SHADER_LIGHTLIST_H

#include "mi_shader_if.h"

namespace mi {
namespace shader_v3 {


class LightIterator {
public:
    LightIterator(
        miState*        state,
        miTag*          shader_light_list = 0,
        int             n_shader_lights = 0,
        int             version = mi_ray_interface_version);

    LightIterator(
        miState*        state,
        const miVector  &axis,
        miScalar        spread_cos,
        miTag*          shader_light_list = 0,
        int             n_shader_lights = 0,
        int             version = mi_ray_interface_version);


    LightIterator(const LightIterator &iter);

    ~LightIterator();

    miTag operator*() const;

    LightList* operator->() const;

    const LightIterator& operator++();

    LightIterator operator++(int);

    bool at_end() const;

    const LightIterator &operator=(const LightIterator &iter);

    bool operator==(const LightIterator &iter) const;

    bool operator!=(const LightIterator &iter) const;

private:
    LightList* m_list;

    size_t m_current;
};


class LightList {
public:

    virtual size_t set_current(size_t current)          = 0;

    virtual size_t get_current() const                  = 0;

    virtual bool sample()                               = 0;

    virtual miScalar get_dot_nl() const                 = 0;

    virtual const miVector& get_direction() const       = 0;

    virtual void get_contribution(miColor *c) const     = 0;

    virtual void get_contribution(miSpectrum *s) const  = 0;

    virtual int get_number_of_samples() const           = 0;

    virtual miTag get_light_tag(size_t current) const   = 0;

    virtual size_t get_number_of_lights() const         = 0;

    virtual void connect()                              = 0;

    virtual void release()                              = 0;
}; 


class Access_bsdf;

class MISLightIterator {
public:

    static void get_direct_lighting(
        miColor*        result,
        miState*        state,
        miColor&        diffuse_color,
        miTag*          shader_light_list = 0,
        int             n_shader_lights = 0,
        int             version = mi_ray_interface_version);

    MISLightIterator(
        miState*        state,
        miTag*          shader_light_list = 0,
        int             n_shader_lights = 0,
        int             version = mi_ray_interface_version);

    MISLightIterator(
        miState*        state,
        Access_bsdf&    bsdf,
        miTag*          shader_light_list = 0,
        int             n_shader_lights = 0,
        int             version = mi_ray_interface_version);

    MISLightIterator(const MISLightIterator &iter);

    ~MISLightIterator();

    miTag operator*() const;

    MISLightList* operator->() const;

    const MISLightIterator& operator++();

    MISLightIterator operator++(int);

    bool at_end() const;

    const MISLightIterator &operator=(const MISLightIterator &iter);

    bool operator==(const MISLightIterator &iter) const;

    bool operator!=(const MISLightIterator &iter) const;

private:
    MISLightList* m_list;

    size_t m_current;
};


class MISLightList {
public:

    virtual size_t set_current(size_t current)          = 0;

    virtual size_t get_current() const                  = 0;

    virtual bool has_bsdf() const                       = 0;

    virtual bool sample()                               = 0;

    virtual miScalar get_dot_nl() const                 = 0;

    virtual const miVector& get_direction() const       = 0;

    virtual void get_contribution(miColor *c) const     = 0;

    virtual void get_bsdf_contribution(miColor *c) const = 0;

    virtual miScalar get_pdf() const                    = 0;

    virtual miScalar get_weight() const                 = 0;

    virtual miScalar get_norm_factor() const            = 0;

    virtual void get_sampled_contribution(miColor *c) const     = 0;

    virtual int get_number_of_samples() const           = 0;

    virtual miTag get_light_tag(size_t current) const   = 0;

    virtual size_t get_number_of_lights() const         = 0;

    virtual void connect()                              = 0;

    virtual void release()                              = 0;
};


//-----------------------------------------------------------------------------
// inline implementation for LightIterator methods
//-----------------------------------------------------------------------------

inline LightIterator::LightIterator(
    miState             *state,
    const miVector      &axis,
    miScalar            spread_cos,
    miTag               *shader_light_list, 
    int                 n_shader_lights,
    int                 version)
: m_list(Access_interface(version)->createLightList(
        state, axis, spread_cos, shader_light_list, n_shader_lights))
, m_current(0)
{
}

inline LightIterator::LightIterator(
    miState             *state,
    miTag               *shader_light_list, 
    int                 n_shader_lights,
    int                 version)
: m_list(Access_interface(version)->createLightList(
        state, state->normal, 0, shader_light_list, n_shader_lights))
, m_current(0)
{
}

inline LightIterator::LightIterator(const LightIterator &iter) 
: m_list(iter.m_list)
, m_current(iter.m_current)
{ 
    if(m_list) m_list->connect();  // maintain reference count 
}

inline LightIterator::~LightIterator() 
{
    if(m_list) m_list->release();  // maintain reference count
}

inline const LightIterator& LightIterator::operator=(const LightIterator &iter)
{
    if(m_list != iter.m_list) {
        // need the compare above, otherwise the release might delete the list
        // and the connect below would be invalid.
        if (m_list) m_list->release();
        m_list = iter.m_list;
        m_list->connect();
    }
    m_current = iter.m_current;
    return *this;
}

inline miTag LightIterator::operator*() const 
{
    return m_list->get_light_tag(m_current);
}

inline LightList* LightIterator::operator->() const
{
    m_list->set_current(m_current);
    return m_list;
}

inline const LightIterator& LightIterator::operator++() 
{
    ++m_current;
    return *this;
}

inline LightIterator LightIterator::operator++(int)
{
    LightIterator res(*this);
    ++m_current;
    return res;
}

inline bool LightIterator::at_end() const
{
    return m_current == m_list->get_number_of_lights();
}

inline bool LightIterator::operator==(const LightIterator &iter) const 
{
    return m_list == iter.m_list && m_current == iter.m_current;
}

inline bool LightIterator::operator!=(const LightIterator &iter) const 
{
    return !this->operator==(iter);
}


//-----------------------------------------------------------------------------
// inline implementation for MISLightIterator methods
//-----------------------------------------------------------------------------

// static convenience method to compute the total direct lighting contribution.
// The diffuse color is needed in case there is no BSDF attached, since in this
// case the core has no way to retrieve it (when a BSDF is there, its contribution
// accounts for the diffuse color and other components)
inline void MISLightIterator::get_direct_lighting(
    miColor*            result,
    miState*            state,
    miColor&            diffuse_color,
    miTag*              shader_light_list,
    int                 n_shader_lights,
    int                 version)
{
    result->r = result->g = result->b = 0.0;
    result->a = 1.0;

    MISLightIterator it(state, shader_light_list, n_shader_lights, version);

    for ( ; !it.at_end () ; ++it) {
        miColor this_light_tot = {0.0, 0.0, 0.0, 1.0};
        
        while (it->sample ()) {
            miColor this_color;
            it->get_sampled_contribution(&this_color);
        
            // the color returned by 'get_sampled_contribution' is already
            // multiplied by the MIS weight, the dot_nl factor, the norm.
            // factor and the inverse of the probability
            this_light_tot.r += this_color.r;
            this_light_tot.g += this_color.g;
            this_light_tot.b += this_color.b;
        }
        
        // normalizes the total contribution of the light by dividing
        // by the number of samples
        int n = it->get_number_of_samples();
        
        if (n>1) {
            float n_inv = 1.0f/(float) n;
            
            this_light_tot.r *= n_inv;
            this_light_tot.g *= n_inv;
            this_light_tot.b *= n_inv;
        }
        
        result->r += this_light_tot.r;
        result->g += this_light_tot.g;
        result->b += this_light_tot.b;
    }

    if (!it->has_bsdf()) {
        // there is no BSDF attached to the current material, the total
        // light contribution must be multiplied by the diffuse color

        result->r *= diffuse_color.r;
        result->g *= diffuse_color.g;
        result->b *= diffuse_color.b;
    }
}

inline MISLightIterator::MISLightIterator(
    miState             *state,
    miTag               *shader_light_list, 
    int                 n_shader_lights,
    int                 version)
: m_list(Access_interface(version)->createMISLightList(
        state, shader_light_list, n_shader_lights))
, m_current(0)
{
}

inline MISLightIterator::MISLightIterator(
    miState             *state,
    Access_bsdf         &bsdf,
    miTag               *shader_light_list, 
    int                 n_shader_lights,
    int                 version)
: m_list(Access_interface(version)->createMISLightList(
        state, bsdf, shader_light_list, n_shader_lights))
, m_current(0)
{
}

inline MISLightIterator::MISLightIterator(const MISLightIterator &iter) 
: m_list(iter.m_list)
, m_current(iter.m_current)
{ 
    if(m_list) m_list->connect();  // maintain reference count 
}

inline MISLightIterator::~MISLightIterator() 
{
    if(m_list) m_list->release();  // maintain reference count
}

inline const MISLightIterator& MISLightIterator::operator=(const MISLightIterator &iter)
{
    if(m_list != iter.m_list) {
        // need the compare above, otherwise the release might delete the list
        // and the connect below would be invalid.
        if (m_list) m_list->release();
        m_list = iter.m_list;
        m_list->connect();
    }
    m_current = iter.m_current;
    return *this;
}

inline miTag MISLightIterator::operator*() const 
{
    return m_list->get_light_tag(m_current);
}

inline MISLightList* MISLightIterator::operator->() const
{
    m_list->set_current(m_current);
    return m_list;
}

inline const MISLightIterator& MISLightIterator::operator++() 
{
    ++m_current;
    return *this;
}

inline MISLightIterator MISLightIterator::operator++(int)
{
    MISLightIterator res(*this);
    ++m_current;
    return res;
}

inline bool MISLightIterator::at_end() const
{
    return m_current == m_list->get_number_of_lights();
}

inline bool MISLightIterator::operator==(const MISLightIterator &iter) const 
{
    return m_list == iter.m_list && m_current == iter.m_current;
}

inline bool MISLightIterator::operator!=(const MISLightIterator &iter) const 
{
    return !this->operator==(iter);
}


}}

#endif //SHADER_LIGHTLIST_H