• home
• up
• index

shader_map.h

Go to the documentation of this file.

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



#ifndef SHADER_MAP_H
#define SHADER_MAP_H

#include "mi_shader_if.h"

namespace mi {
namespace shader_v3 {

class Map_status {
    public:
        enum Status_code {
            OK = 0,

            Insufficient_memory,
            No_such_field,
            Out_of_bounds,
            No_declaration,
            Declaration_mismatch,
            Wrong_dimension,

            File_could_not_be_opened = 16,
            File_not_a_map,
            File_version_unsupported,
            
            Field_undefined = 32,
            Field_name_too_long,
            Field_name_empty,
            Field_name_illegal,
            Field_null_array,
            Field_type_mismatch,

            Iterator_invalid = 48,
            Iterator_past_end,
            Iterator_out_of_bounds,
            
            Lookup_invalid = 64,
            Lookup_past_end,
            Lookup_out_of_bounds,
            Lookup_dimension_mismatch
        };

        Map_status()
            : m_status(OK)
        {}

        Map_status(Status_code status)
            : m_status(status)
        {}

        Map_status(const Map_status& status)
            : m_status(status.m_status)
        {}

        Map_status& operator=(const Status_code& rhs)
        {m_status=rhs;return *this;}

        Map_status& operator=(const Map_status& rhs)
        {m_status=rhs.m_status;return *this;}

        bool operator==(const Status_code rhs) const
        {return m_status==rhs;}

        bool operator==(const Map_status& rhs) const
        {return m_status==rhs.m_status;}

        bool operator!=(const Status_code rhs) const
        {return m_status!=rhs;}

        bool operator!=(const Map_status& rhs) const
        {return m_status!=rhs.m_status;}
        
        bool is_ok() const
        {return m_status==OK;}

        Status_code status() const
        {return m_status;}

    private:
        Status_code m_status;
};

class Map_field_type {
    public:
        enum Type {
            Undefined = 0,

            Scalar,
            Integer,
            Vector,
            Color,
            Transform,

            Scalar_array = 16,
            Integer_array
        };

        Map_field_type()
            : m_type(Undefined)
        {}

        Map_field_type(Type type)
            : m_type(type)
        {}

        Map_field_type(const Map_field_type& type)
            : m_type(type.m_type)
        {}

        Map_field_type& operator=(const Type& rhs)
        {m_type=rhs;return *this;}

        Map_field_type& operator=(const Map_field_type& rhs)
        {m_type=rhs.m_type;return *this;}

        bool operator==(const Type rhs) const
        {return m_type==rhs;}

        bool operator==(const Map_field_type& rhs) const
        {return m_type==rhs.m_type;}

        bool operator!=(const Type rhs) const
        {return m_type!=rhs;}

        bool operator!=(const Map_field_type& rhs) const
        {return m_type!=rhs.m_type;}

        Type type() const
        {return m_type;}

    private:
        Type m_type;
};

typedef miUint Map_field_id;

class Map_declaration;
class Map_element;
class Map_lookup;

class Map_base {
    public:
        virtual miUint size() const = 0;

        virtual bool is_empty() const = 0;

        virtual bool has_declaration() const = 0;

        virtual Map_status get(
            const miUint    index,
            Map_element     &map_element) const = 0;

        virtual Map_status set(
            const miUint        index,
            const Map_element   &map_element) = 0;

        virtual Map_status append(
            const Map_element   &map_element) = 0;

        virtual Map_status read(
            const char  *file_name) = 0;

        virtual Map_status append_to(
            const char  *file_name) const = 0;

        virtual Map_status append_from(
            const char  *file_name) = 0;

        virtual Map_status write(
            const char  *file_name) const = 0;
};

class Map_access_dbhandle {
public:
    virtual const Map_base * operator->() = 0;

    virtual void release() const = 0;

    virtual miTag get_tag() const = 0;

    virtual miTag store() = 0;
};

class Map_access {
public:
    Map_access(
        const miTag tag);

    Map_access(
        const char *filename,
        Map_status *status = 0);

    ~Map_access();

    const Map_base * operator->();

    const Map_base * operator->() const;

    miTag get_tag() const;

    miTag store();

private:
    Map_access();
    Map_access(const Map_access &);
    const Map_access & operator=(const Map_access &);

    Map_access_dbhandle *m_map_h;
};

class Map_edit_dbhandle {
public:
    virtual Map_base * operator->() = 0;

    virtual void release() const = 0;

    virtual miTag get_tag() const = 0;

    virtual miTag store() = 0;
};

class Map_edit {
public:
    Map_edit(
        const Map_declaration &map_declaration);

    Map_edit();

    Map_edit(
        const miTag tag);

    Map_edit(
        const char *filename,
        Map_status *status = 0);

    ~Map_edit();

    Map_base * operator->();

    const Map_base * operator->() const;

    miTag get_tag() const;

    miTag store();

private:
    Map_edit(const Map_edit &);
    const Map_edit & operator=(const Map_edit &);

    Map_edit_dbhandle *m_map_h;
};

class Map_declaration_base {
    public:
        virtual void release() const = 0;

        virtual miUint size() const = 0;

        virtual bool is_empty() const = 0;

        virtual miUint get_dimension() const = 0;

        virtual bool is_equivalent(
            const Map_declaration   &other,
            Map_status              *status = 0) const = 0;

        virtual bool matches(
            const Map_declaration   &other,
            Map_status              *status = 0) const = 0;

        virtual bool has_field(
            const char  *name,
            Map_status  *status = 0) const = 0;

        virtual Map_status add(
            const char              *name,
            const Map_field_type    type,
            const miUint            dim = 0) = 0;

        virtual Map_status add_scalar(
            const char      *name) = 0;

        virtual Map_status add_integer(
            const char      *name) = 0;

        virtual Map_status add_vector(
            const char      *name) = 0;

        virtual Map_status add_color(
            const char      *name) = 0;

        virtual Map_status add_transform(
            const char      *name) = 0;

        virtual Map_status add_scalar_array(
            const char      *name,
            const miUint    dim) = 0;

        virtual Map_status add_integer_array(
            const char      *name,
            const miUint    dim) = 0;

        virtual const char* get_field_name(
            const Map_field_id  field_id,
            Map_status          *status = 0) const = 0;

        virtual Map_field_id get_field_id(
            const char      *field_name,
            Map_status      *status = 0) const = 0;

        virtual Map_status get_field_type_dim(
            const Map_field_id  field_id,
            Map_field_type      &field_type,
            miUint              &field_dimension) const = 0;

        virtual Map_status get_field_type_dim(
            const char          *field_name,
            Map_field_type      &field_type,
            miUint              &field_dimension) const = 0;
};

class Map_declaration {
public:
    Map_declaration(
        const miUint dimension=3);

    Map_declaration(
        const Map_access &map,
        Map_status *status = 0);

    Map_declaration(
        const Map_edit &map,
        Map_status *status = 0);

    Map_declaration(
        const Map_element &map_element,
        Map_status *status = 0);

    Map_declaration(
        const Map_declaration &other,
        Map_status *status = 0);

    ~Map_declaration();

    Map_declaration & operator=(
        const Map_declaration &other);

    Map_declaration_base * operator->();

    const Map_declaration_base * operator->() const;

private:
    Map_declaration_base *m_map_declaration;
};

class Map_element_base {
    public:
        virtual void release() const = 0;

        virtual Map_status set_declaration(
            const Map_declaration&  declaration) = 0;

        virtual Map_status get_position(
            float               *position) const = 0;

        virtual Map_status get_position(
            miVector            &position) const = 0;

        virtual Map_status get(
            const Map_field_id  field_id,
            float               &value) const = 0;

        virtual Map_status get(
            const Map_field_id  field_id,
            int                 &value) const = 0;

        virtual Map_status get(
            const Map_field_id  field_id,
            miVector            &value) const = 0;

        virtual Map_status get(
            const Map_field_id  field_id,
            miColor             &value) const = 0;

        virtual Map_status get(
            const Map_field_id  field_id,
            miMatrix            *value) const = 0;

        virtual Map_status get(
            const Map_field_id  field_id,
            float               *value) const = 0;

        virtual Map_status get(
            const Map_field_id  field_id,
            int                 *value) const = 0;

        virtual Map_status set_position(
            const float         *position) = 0;

        virtual Map_status set_position(
            const miVector      &position) = 0;

        virtual Map_status set(
            const Map_field_id  field_id,
            const float         value) = 0;

        virtual Map_status set(
            const Map_field_id  field_id,
            const int           value) = 0;

        virtual Map_status set(
            const Map_field_id  field_id,
            const miVector      &value) = 0;

        virtual Map_status set(
            const Map_field_id  field_id,
            const miColor       &value) = 0;

        virtual Map_status set(
            const Map_field_id  field_id,
            const miMatrix      *value) = 0;

        virtual Map_status set(
            const Map_field_id  field_id,
            const float         *value) = 0;

        virtual Map_status set(
            const Map_field_id  field_id,
            const int           *value) = 0;
};

class Map_element {
public:
    Map_element();

    Map_element(
        const Map_declaration& declaration);

    Map_element(
        const Map_element &other);

    ~Map_element();

    Map_element & operator=(
        const Map_element &other);

    Map_element_base * operator->(); 

    const Map_element_base * operator->() const; 

private:
    Map_element_base *m_map_element;
};

class Map_iterator_base {
    public:
        virtual void release() const = 0;

        virtual Map_status reset() const = 0;

        virtual Map_status set_to(
            const miUint    index) const = 0;

        virtual Map_status next() const = 0;

        virtual Map_status previous() const = 0;

        virtual Map_status skip(
            const miUint    amount) const = 0;

        virtual bool at_end(
            Map_status  *status = 0) const = 0;

        virtual miUint current(
            Map_status  *status = 0) const = 0;

        virtual Map_status get(
            Map_element         &element) const = 0;

        virtual Map_status get_position(
            float               *position) const = 0;

        virtual Map_status get_position(
            miVector            &position) const = 0;

        virtual Map_status get(
            const Map_field_id  field_id,
            float               &value) const = 0;

        virtual Map_status get(
            const Map_field_id  field_id,
            int                 &value) const = 0;

        virtual Map_status get(
            const Map_field_id  field_id,
            miVector            &value) const = 0;

        virtual Map_status get(
            const Map_field_id  field_id,
            miColor             &value) const = 0;

        virtual Map_status get(
            const Map_field_id  field_id,
            miMatrix            *value) const = 0;

        virtual Map_status get(
            const Map_field_id  field_id,
            float               *value) const = 0;

        virtual Map_status get(
            const Map_field_id  field_id,
            int                 *value) const = 0;

        virtual Map_status set(
            const Map_element   &element) = 0;

        virtual Map_status set_position(
            const float         *position) = 0;

        virtual Map_status set_position(
            const miVector      &position) = 0;

        virtual Map_status set(
            const Map_field_id  field_id,
            const float         value) = 0;

        virtual Map_status set(
            const Map_field_id  field_id,
            const int           value) = 0;

        virtual Map_status set(
            const Map_field_id  field_id,
            const miVector      &value) = 0;

        virtual Map_status set(
            const Map_field_id  field_id,
            const miColor       &value) = 0;

        virtual Map_status set(
            const Map_field_id  field_id,
            const miMatrix      *value) = 0;

        virtual Map_status set(
            const Map_field_id  field_id,
            const float         *value) = 0;

        virtual Map_status set(
            const Map_field_id  field_id,
            const int           *value) = 0;
};

class Map_iterator_edit;

class Map_iterator_access {
public:
    Map_iterator_access(
        const Map_access &map,
        Map_status *status = 0);

    Map_iterator_access(
        const Map_edit &map,
        Map_status *status = 0);

    Map_iterator_access(
        const Map_iterator_access &other,
        Map_status *status = 0);

    Map_iterator_access(
        const Map_iterator_edit &other,
        Map_status *status = 0);

    ~Map_iterator_access();

    Map_iterator_access & operator=(
        const Map_iterator_access &other);

    Map_iterator_access & operator=(
        const Map_iterator_edit &other);

    const Map_iterator_base * operator->(); 

private:
    Map_iterator_base *m_map_iterator;
};

class Map_iterator_edit {
public:
    Map_iterator_edit(
        const Map_edit &map,
        Map_status *status = 0);

    Map_iterator_edit(
        const Map_iterator_edit &other,
        Map_status *status = 0);

    ~Map_iterator_edit();

    Map_iterator_edit & operator=(
        const Map_iterator_edit &other);

    Map_iterator_base * operator->(); 

    const Map_iterator_base * operator->() const; 

private:
    Map_iterator_base *m_map_iterator;
};

class Map_distance_base {
public:
    virtual const miUint get_dimension() const = 0;

    virtual const float *get_point() const = 0;

    virtual float operator() (
        const float *min,
        const float *max) const = 0;

    virtual float operator() (
        const Map_iterator_base *element) const = 0;
};


template<miUint DIM>
class Map_distance : public mi::shader_v3::Map_distance_base {
public:
    static const miUint DIMENSION = DIM;

    Map_distance()
    {}

    Map_distance(
        const float *point)
    {
        for (miUint i = 0; i < DIMENSION; ++i)
            m_point[i] = point[i];
    }

    const miUint get_dimension() const { return DIMENSION; }

    const float *get_point() const { return m_point; }

    float operator() (
        const float *min,
        const float *max) const
    {
        float d = 0.0f;
        float da, db, max_da_db, tmp;

        for (miUint i = 0; i < DIMENSION; ++i) {
            da = min[i] - m_point[i];
            db = m_point[i] - max[i];

            max_da_db = da > db ? da : db;
            tmp = max_da_db > 0.0f ? max_da_db : 0.0f;

            d += tmp * tmp;
        }

        return d;
    }

    virtual float operator() (
        const Map_iterator_base *element) const = 0;

protected:
    float m_point[DIM];
};

template<miUint DIM>
class Map_quad_distance : public mi::shader_v3::Map_distance<DIM> {
public:
    Map_quad_distance(
        const float *point)
        : Map_distance<DIM>::Map_distance(point)
    {}

    float operator() (
        const Map_iterator_base *element) const
    {
        float d = 0.0f;
        float diff;
        float position[DIM];

        element->get_position(position);

        for (miUint i = 0; i < DIM; ++i) {
            diff = this->m_point[i] - position[i];
            d += diff * diff;
        }

        return d;
    }
};

typedef Map_quad_distance<3> Map_quad_distance3;

struct Map_lookup_entry {
    miUint  index;

    float   distance;
};

class Map_lookup_base {
    public:
        virtual void release() const = 0;

        virtual miUint size() const = 0;

        virtual bool is_empty() const = 0;

        virtual Map_status reset() = 0;

        virtual Map_status next() = 0;

        virtual bool at_end(
            Map_status  *status = 0) const = 0;

        virtual Map_status sort() = 0;

        virtual Map_status sort_descending() = 0;

        virtual Map_lookup_entry get(
            const miUint    n,
            Map_status      *status = 0) const = 0;

        virtual Map_lookup_entry get(
            Map_status  *status = 0) const = 0;

        virtual miUint get_index(
            Map_status  *status = 0) const = 0;

        virtual float get_distance(
            Map_status  *status = 0) const = 0;

        virtual Map_status get(
            Map_element &element) const = 0;

        virtual Map_status get_position(
            float       *position) const = 0;

        virtual Map_status get_position(
            miVector    &position) const = 0;

        virtual Map_status get(
            const Map_field_id  field_id,
            float               &value) const = 0;

        virtual Map_status get(
            const Map_field_id  field_id,
            int                 &value) const = 0;

        virtual Map_status get(
            const Map_field_id  field_id,
            miVector            &value) const = 0;

        virtual Map_status get(
            const Map_field_id  field_id,
            miColor             &value) const = 0;

        virtual Map_status get(
            const Map_field_id  field_id,
            miMatrix            *value) const = 0;

        virtual Map_status get(
            const Map_field_id  field_id,
            float               *value) const = 0;

        virtual Map_status get(
            const Map_field_id  field_id,
            int                 *value) const = 0;

        virtual Map_status search(
            const Map_distance_base &distance_functor,
            const miUint        max_elements = 1,
            const float         max_search_dist = miHUGE_SCALAR) = 0;

        virtual Map_status search(
            const miVector      &point,
            const miUint        max_elements = 1,
            const float         max_search_dist = miHUGE_SCALAR) = 0;
};

class Map_lookup {
public:
    Map_lookup(
        const Map_access &map,
        Map_status *status = 0);

    Map_lookup(
        const Map_lookup &other,
        Map_status *status = 0);

    ~Map_lookup();

    Map_lookup & operator=(
        const Map_lookup &other);

    Map_lookup_base * operator->(); 

private:
    Map_lookup_base* m_map_lookup;
};

inline Map_access::Map_access(
    const miTag tag)
    : m_map_h(0)
{
    m_map_h = Interface_access()->accessMap(tag);
}

inline Map_access::Map_access(
    const char *filename,
    Map_status *status)
    : m_map_h(0)
{
    m_map_h = Interface_access()->accessMap(filename, status);
}

inline Map_access::~Map_access()
{
    if(m_map_h != 0)
        m_map_h->release();
}

inline const Map_base * Map_access::operator->()
{
    if(m_map_h != 0){
        return (*m_map_h).operator->();
    }
    return 0;
}

inline const Map_base * Map_access::operator->() const
{
    if(m_map_h != 0){
        return (*m_map_h).operator->();
    }
    return 0;
}

inline miTag Map_access::get_tag() const
{
    if(m_map_h != 0){
        return m_map_h->get_tag();
    }
    return 0;
}

inline miTag Map_access::store()
{
    if(m_map_h != 0){
        return m_map_h->store();
    }
    return 0;
}

inline Map_edit::Map_edit(
    const Map_declaration &map_declaration)
    : m_map_h(0)
{
    m_map_h = Interface_access()->createMap(map_declaration.operator->());
}

inline Map_edit::Map_edit()
    : m_map_h(0)
{
    m_map_h = Interface_access()->createMap();
}

inline Map_edit::Map_edit(
    const miTag tag)
    : m_map_h(0)
{
    m_map_h = Interface_access()->editMap(tag);
}

inline Map_edit::Map_edit(
    const char *filename,
    Map_status *status)
    : m_map_h(0)
{
    m_map_h = Interface_access()->editMap(filename, status);
}

inline Map_edit::~Map_edit()
{
    if(m_map_h != 0)
        m_map_h->release();
}

inline Map_base * Map_edit::operator->()
{
    if(m_map_h != 0){
        return (*m_map_h).operator->();
    }
    return 0;
}

inline const Map_base * Map_edit::operator->() const
{
    if(m_map_h != 0){
        return (*m_map_h).operator->();
    }
    return 0;
}

inline miTag Map_edit::get_tag() const
{
    if(m_map_h != 0){
        return m_map_h->get_tag();
    }
    return 0;
}

inline miTag Map_edit::store()
{
    if(m_map_h != 0){
        return m_map_h->store();
    }
    return 0;
}

inline Map_declaration::Map_declaration(
    miUint dimension)
    : m_map_declaration(0)
{
    m_map_declaration = Interface_access()->createMapDeclaration(
        dimension);
}

inline Map_declaration::Map_declaration(
    const Map_access &map,
    Map_status *status)
    : m_map_declaration(0)
{
    m_map_declaration = Interface_access()->copyMapDeclaration(
        map.operator->(), status);
}

inline Map_declaration::Map_declaration(
    const Map_edit &map,
    Map_status *status)
    : m_map_declaration(0)
{
    m_map_declaration = Interface_access()->copyMapDeclaration(
        map.operator->(), status);
}

inline Map_declaration::Map_declaration(
    const Map_element &map_element,
    Map_status *status)
    : m_map_declaration(0)
{
    m_map_declaration = Interface_access()->copyMapDeclaration(
        map_element.operator->(), status);
}

inline Map_declaration::Map_declaration(
    const Map_declaration &other,
    Map_status *status)
    : m_map_declaration(0)
{
    m_map_declaration = Interface_access()->copyMapDeclaration(
        other.m_map_declaration, status);
}

inline Map_declaration & Map_declaration::operator=(
    const Map_declaration &other)
{
    if (m_map_declaration != 0)
        m_map_declaration->release();
    m_map_declaration = Interface_access()->copyMapDeclaration(
        other.m_map_declaration, 0);
    return *this;
}

inline Map_declaration::~Map_declaration()
{
    if (m_map_declaration != 0)
        m_map_declaration->release();
}

inline Map_declaration_base * Map_declaration::operator->()
{
    return m_map_declaration;
}

inline const Map_declaration_base * Map_declaration::operator->() const
{
    return m_map_declaration;
}

inline Map_element::Map_element()
    : m_map_element(0)
{
    m_map_element = Interface_access()->createMapElement();
}

inline Map_element::Map_element(
    const Map_declaration &declaration)
    : m_map_element(0)
{
    m_map_element = Interface_access()->createMapElement(
        declaration.operator->());
}

inline Map_element::Map_element(
    const Map_element &other)
    : m_map_element(0)
{
    m_map_element = Interface_access()->copyMapElement(
        other.m_map_element);
}

inline Map_element & Map_element::operator=(
    const Map_element &other)
{
    m_map_element->release();
    m_map_element = Interface_access()->copyMapElement(
        other.m_map_element);
    return *this;
}

inline Map_element::~Map_element()
{
    m_map_element->release();
}

inline Map_element_base * Map_element::operator->()
{
    return m_map_element;
}

inline const Map_element_base * Map_element::operator->() const
{
    return m_map_element;
}

inline Map_iterator_access::Map_iterator_access(
    const Map_access &map,
    Map_status *status)
    : m_map_iterator(0)
{
    m_map_iterator = Interface_access()->createMapIterator(
        map.operator->(), status);
}

inline Map_iterator_access::Map_iterator_access(
    const Map_edit &map,
    Map_status *status)
    : m_map_iterator(0)
{
    m_map_iterator = Interface_access()->createMapIterator(
        map.operator->(), status);
}

inline Map_iterator_access::Map_iterator_access(
    const Map_iterator_access &other,
    Map_status *status)
    : m_map_iterator(0)
{
    m_map_iterator = Interface_access()->copyMapIterator(
        other.m_map_iterator, status);
}

inline Map_iterator_access::Map_iterator_access(
    const Map_iterator_edit &other,
    Map_status *status)
    : m_map_iterator(0)
{
    m_map_iterator = Interface_access()->copyMapIterator(
        other.operator->(), status);
}

inline Map_iterator_access & Map_iterator_access::operator =(
    const Map_iterator_access &other)
{
    m_map_iterator->release();
    m_map_iterator = Interface_access()->copyMapIterator(
        other.m_map_iterator, 0);
    return *this;
}

inline Map_iterator_access & Map_iterator_access::operator =(
    const Map_iterator_edit &other)
{
    if (m_map_iterator != 0)
        m_map_iterator->release();
    m_map_iterator = Interface_access()->copyMapIterator(
        other.operator->(), 0);
    return *this;
}

inline Map_iterator_access::~Map_iterator_access()
{
    if (m_map_iterator != 0)
        m_map_iterator->release();
}

inline const Map_iterator_base * Map_iterator_access::operator->()
{
    return m_map_iterator;
}

inline Map_iterator_edit::Map_iterator_edit(
    const Map_edit &map,
    Map_status *status)
    : m_map_iterator(0)
{
    m_map_iterator = Interface_access()->createMapIterator(
        map.operator->(), status);
}

inline Map_iterator_edit::Map_iterator_edit(
    const Map_iterator_edit &other,
    Map_status *status)
    : m_map_iterator(0)
{
    m_map_iterator = Interface_access()->copyMapIterator(
        other.m_map_iterator, status);
}

inline Map_iterator_edit & Map_iterator_edit::operator =(
    const Map_iterator_edit &other)
{
    if (m_map_iterator != 0)
        m_map_iterator->release();
    m_map_iterator = Interface_access()->copyMapIterator(
        other.m_map_iterator, 0);
    return *this;
}

inline Map_iterator_edit::~Map_iterator_edit()
{
    if (m_map_iterator != 0)
        m_map_iterator->release();
}

inline Map_iterator_base * Map_iterator_edit::operator->()
{
    return m_map_iterator;
}

inline const Map_iterator_base * Map_iterator_edit::operator->() const
{
    return m_map_iterator;
}

inline Map_lookup::Map_lookup(
    const Map_access &map,
    Map_status *status)
    : m_map_lookup(0)
{
    m_map_lookup = Interface_access()->createMapLookup(
        map.operator->(), status);
}

inline Map_lookup::Map_lookup(
    const Map_lookup &other,
    Map_status *status)
    : m_map_lookup(0)
{
    m_map_lookup = Interface_access()->copyMapLookup(
        other.m_map_lookup, status);
}

inline Map_lookup::~Map_lookup()
{
    if (m_map_lookup != 0)
        m_map_lookup->release();
}

inline Map_lookup & Map_lookup::operator = (
    const Map_lookup &other)
{
    if (m_map_lookup != 0)
        m_map_lookup->release();
    m_map_lookup = Interface_access()->copyMapLookup(
        other.m_map_lookup, 0);
    return *this;
}

inline Map_lookup_base * Map_lookup::operator->()
{
    return m_map_lookup;
}

} // namespace shader_v3
} // namespace mi

#endif //SHADER_MAP_H

• home
• up
• index

Copyright © 1986-2008 by mental images GmbH