home

up

contents

mi_shader_if.h

Go to the documentation of this file.

// Copyright 1986-2006 by mental images GmbH, Fasanenstr. 81, D-10623 Berlin,
// Germany. All rights reserved.
// Author:      kjs
// Created:     09.01.06
// Module:      api
// Purpose:     mental ray C++ shader interface extensions


#ifndef MI_SHADER_IF_H
#define MI_SHADER_IF_H

#if !defined(SHADER_H)
#include <mi_raylib.h>
#include <mi_lib.h>
#endif

#ifndef __cplusplus
#error mi_shader_if.h requires C++ compilation
#endif


static const int mi_ray_interface_version = 1;


// forward declarations
namespace mi {
    namespace shader {
        class Interface;
    }
}



extern "C" mi::shader::Interface *mi_get_shader_interface(int version = mi_ray_interface_version);


namespace mi {


namespace shader {


struct Options;
class LightList;



class Interface {
public:

    static inline Interface* get(int version = mi_ray_interface_version)
        { return mi_get_shader_interface(version); }

    virtual Options* getOptions(miTag options_tag);

    virtual LightList* createLightList(miState* state, miTag* slist=0, int n=0);

    virtual void release();
};



struct Options {

    virtual void set(const char *name, bool value) = 0;

    virtual void set(const char *name, const char *value) = 0;

    virtual void set(const char *name, int value) = 0;

    virtual void set(const char *name, float value) = 0;

    virtual void set(const char *name, float value1, float value2, float value3) = 0;

    virtual void set(const char *name, float value1, float value2, float value3, float value4) = 0;

    virtual bool get(const char *name, bool *value) = 0;

    virtual bool get(const char *name, const char **value) = 0;

    virtual bool get(const char *name, int *value) = 0;

    virtual bool get(const char *name, float *value) = 0;

    virtual bool get(const char *name, float *value1, float *value2, float *value3) = 0;

    virtual bool get(const char *name, float *value1, float *value2, float *value3, float *value4) = 0;

    virtual void release() = 0;
};


class LightIterator {
public:
    LightIterator(                                  
        miState* state,                             // the state
        miTag*   shader_light_list = 0,             // optional array of light tags
        int      n_shader_lights = 0);              // number of lights in above array

    LightIterator(const LightIterator& liter);      
    ~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; 

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, 
    miTag*   shader_light_list, 
    int      n_shader_lights)
: m_list(0)
, m_current(0)
{
    Interface* iface;
    mi_query(miQ_RAY_INTERFACE, state, 0, &iface);
    m_list = iface->createLightList(state, shader_light_list, n_shader_lights);
}

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

inline LightIterator::~LightIterator() 
{
    if(m_list) m_list->release();
}

inline const LightIterator& LightIterator::operator=(const LightIterator& iter) 
{
    m_list    = iter.m_list;
    m_current = iter.m_current;
    if(m_list) m_list->connect();
    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 operator!=(const LightIterator& i1, const LightIterator& i2) 
{
    return !(i1 == i2);
}

LightList* LightListFactory(
    miState*    state,                  
    miTag*      shader_light_list = 0,  
    int         n_shader_lights   = 0); 

} // namespace shader
} // namespace mi


#endif // MI_SHADER_IF_H

home

up

contents

Copyright © 1986-2006 by mental images GmbH