shader_framebuffer.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_FRAMEBUFFER_H
#define SHADER_FRAMEBUFFER_H
#include "mi_shader_if.h"

namespace mi {
namespace shader_v3 {


class Framebuffer {
    public:
        virtual bool set(
            const char  *buffer, 
            const char  *param, 
            const       bool value) = 0;

        virtual bool set(
            const char  *buffer, 
            const char  *param, 
            const float value) = 0;

        virtual bool set(
            const char  *buffer, 
            const char  *param, 
            const int   value) = 0;

        virtual bool set(
            const char  *buffer, 
            const char  *param, 
            const char  *value) = 0;

        virtual bool get(
            const char  *buffer, 
            const char  *param, 
            bool        &value) const = 0;

        virtual bool get(
            const char  *buffer, 
            const char  *param, 
            float       &value) const = 0;

        virtual bool get(
            const char  *buffer, 
            const char  *param, 
            int         &value) const = 0;

        virtual bool get(
            const char  *buffer, 
            const char  *param, 
            const char  *&value) const = 0;

        virtual bool get_index(const char *buffer, size_t &index) const = 0;

        virtual bool reset() = 0;

        virtual void echo(FILE *) const = 0;

        virtual bool get_buffercount(size_t &buffercount) const = 0;

        virtual bool get_buffername(size_t num, const char *&name) const = 0;

        virtual bool remove(const char *buffer) = 0;

        virtual bool map_old_index(const unsigned int rc_index, int &index) const = 0;

        virtual bool get_datatype(size_t num, miImg_type& type) const = 0;

};

class Access_fb {
    public:
        Access_fb(
            miTag tag);

        ~Access_fb();

        const Framebuffer * operator->() const;
    private:
        Access_fb();
        Access_fb(const Access_fb &);
        const Access_fb & operator=(const Access_fb &);
        mi::shader_v3::Interface        *m_iface;
        const Framebuffer               *const m_fb;
        const miTag                     m_tag;
};



class Edit_fb {
    public:
        Edit_fb(
            miTag tag);

        ~Edit_fb();

        Framebuffer * operator->() const;
    private:
        Edit_fb();
        Edit_fb(const Edit_fb &);
        const Edit_fb & operator=(const Edit_fb &);
        mi::shader_v3::Interface        *m_iface;
        Framebuffer                     *const m_fb;
        const miTag                     m_tag;
};

inline Access_fb::Access_fb(
    miTag tag)
  : m_iface(mi_get_shader_interface())
  , m_fb(m_iface->accessFramebuffer(tag))
  , m_tag(tag)
{
}

inline Access_fb::~Access_fb()
{
    if (m_fb != 0) {
        m_iface->releaseFramebuffer(m_fb, m_tag);
    }
    m_iface->release();
}

inline const Framebuffer * Access_fb::operator->() const
{
    return m_fb;
}

inline Edit_fb::Edit_fb(
    miTag tag)
  : m_iface(mi_get_shader_interface())
  , m_fb(m_iface->editFramebuffer(tag))
  , m_tag(tag)
{
}

inline Edit_fb::~Edit_fb()
{
    if (m_fb != 0) {
        m_iface->releaseFramebuffer(m_fb, m_tag);
    }
    m_iface->release();
}

inline Framebuffer * Edit_fb::operator->() const
{
    return m_fb;
}



class Merge_pass
{
    public:
        Merge_pass(miState* state);

        const void* get_cur_sample(
            const char*         fb_name);

        const void* get_pass_sample(
            const char*         fb_name);

        bool set_sample(
            const char*         fb_name,
            void*               sample);

        const void* get_cur_sample(
            size_t              fb_index);
        const void* get_pass_sample(
            size_t              fb_index);

        bool set_sample(
            size_t              fb_index,
            void*               sample);

        size_t get_cur_pass_number();

    private:
        mi::shader_v3::Interface        *m_iface;
        miState                         *m_state;
};


inline Merge_pass::Merge_pass(
    miState*    state)
  : m_iface(mi_get_shader_interface())
  , m_state(state)
{
}

inline const void* Merge_pass::get_cur_sample(
    const char* fb_name)
{
    size_t index(size_t(-1));
    Access_fb fb(m_state->camera->buffertag);
    if(!fb->get_index(fb_name, index))
        return NULL;

    return m_iface->renderpass_get_cur_sample(m_state, index);
}

inline const void* Merge_pass::get_pass_sample(
    const char* fb_name)
{
    size_t index(size_t(-1));
    Access_fb fb(m_state->camera->buffertag);
    if(!fb->get_index(fb_name, index))
        return NULL;

    return m_iface->renderpass_get_pass_sample(m_state, index);
}

inline bool Merge_pass::set_sample(
    const char* fb_name,
    void*       sample)
{
    size_t index(size_t(-1));
    Access_fb fb(m_state->camera->buffertag);
    if(!fb->get_index(fb_name, index))
        return false;

    return m_iface->renderpass_set_sample(m_state, index, sample);
}


inline const void* Merge_pass::get_cur_sample(
    size_t      index)
{
    return m_iface->renderpass_get_cur_sample(m_state, index);
}

inline const void* Merge_pass::get_pass_sample(
    size_t      index)
{
    return m_iface->renderpass_get_pass_sample(m_state, index);
}

inline bool Merge_pass::set_sample(
    size_t      index,
    void*       sample)
{
    return m_iface->renderpass_set_sample(m_state, index, sample);
}

inline size_t Merge_pass::get_cur_pass_number()
{
    return m_iface->renderpass_get_pass_number(m_state);
}

}}

#endif //SHADER_FRAMEBUFFER_H