• home
• up
• index

shader_lightlist.h

Go to the documentation of this file.

// Copyright 1986-2009 by mental images GmbH, Fasanenstr. 81, D-10623 Berlin,
// Germany. 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;
}; 


//-----------------------------------------------------------------------------
// 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);
}


}}

#endif //SHADER_LIGHTLIST_H

• home
• up
• index

Copyright © 1986-2010 by mental images GmbH