mi_shader_if.h

Go to the documentation of this file.

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


#ifndef MI_SHADER_IF_H
#define MI_SHADER_IF_H

// if file is included internally
#if !defined(SHADER_H)
#include <mi_raylib.h>
#include <mi_lib.h>
#include <mi_shader.h>
#endif

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


static const int mi_ray_interface_version = 3;

namespace mi {
namespace shader_v3 {
struct Interface;
}}



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

namespace mi {


namespace shader_v3 {


class Options;
class LightList;
class MISLightList;
class Framebuffer;
class Map_status;
class Map_base;
class Edit_map_dbhandle;
class Access_map_dbhandle;
class Access_map;
class Edit_map;
class Map_declaration_base;
class Map_iterator_base;
class Map_element_base;
class Map_lookup_base;
class Bsdf;
class Access_bsdf;
class Subdivision34;
class Mip_remap;




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

    virtual Options *getOptions(
        miTag           string_options);

    virtual miTag createFramebuffer();

    virtual miTag copyFramebuffer(
        miTag           old_buffer_tag);

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

    virtual void release();


    virtual LightList *createLightList(
        miState         *state,
        const miVector  &axis,
        miScalar        spread_cos,
        miTag           *slist = 0, 
        int             n = 0);


    virtual Edit_map_dbhandle *createMap(
        const Map_declaration_base  *map_declaration = 0);

    virtual Access_map_dbhandle *accessMap(
        const miTag             map_tag);

    virtual Edit_map_dbhandle *editMap(
        const miTag             map_tag);

    virtual Access_map_dbhandle *accessMap(
        const char              *filename,
        Map_status              *status);

    virtual Edit_map_dbhandle *editMap(
        const char              *filename,
        Map_status              *status);

    virtual Map_declaration_base *createMapDeclaration(
        const miUint            dimension);

    virtual Map_declaration_base *copyMapDeclaration(
        const Map_declaration_base  *other,
        Map_status                  *status);

    virtual Map_declaration_base *copyMapDeclaration(
        const Map_element_base  *map_element,
        Map_status              *status);

    virtual Map_declaration_base *copyMapDeclaration(
        const Map_base          *map,
        Map_status              *status);

    virtual Map_element_base *createMapElement(
        const Map_declaration_base  *declaration = 0);

    virtual Map_element_base *copyMapElement(
        const Map_element_base  *other);

    virtual Map_iterator_base *createMapIterator(
        const Map_base          *map,
        Map_status              *status);

    virtual Map_iterator_base *copyMapIterator(
        const Map_iterator_base *other,
        Map_status              *status);

    virtual Map_lookup_base *createMapLookup(
        const Map_base          *map,
        Map_status              *status);

    virtual Map_lookup_base *copyMapLookup(
        const Map_lookup_base   *other,
        Map_status              *status);


    virtual const Framebuffer *accessFramebuffer(
        miTag           buffer_tag);

    virtual bool releaseFramebuffer(
        const Framebuffer       *buffer,                           
        miTag                   buffer_tag);

    virtual Framebuffer *editFramebuffer(
        miTag           buffer_tag);

    virtual bool releaseFramebuffer(
        Framebuffer             *buffer,                           
        miTag                   buffer_tag);



    virtual Bsdf* allocBsdf(
            miState*            state);
 
    virtual void releaseBsdf(
            Bsdf*               bsdf, 
            miState*            state);


    virtual Subdivision34 * accessSubdivision34(
            miTag               tag);

    virtual void releaseSubdivision34(
            const Subdivision34 *subdiv34);

    virtual bool lookup_filter_color_texture(
            miColor * const     color,
            miState * const     state,
            const miTag         tex,
            Mip_remap &         remap,
            miVector *          coord);

    virtual bool open_output_image(
            miImg_image *       &image,
            miState *           state,
            const size_t        idx);

    virtual bool close_output_image(
                miState *           state,
                const size_t        idx);



    virtual const void* renderpass_get_cur_sample(
                miState *       state,
                const size_t    idx);

    virtual const void* renderpass_get_pass_sample(
                miState *       state,
                const size_t    idx);

    virtual bool renderpass_set_sample(
                miState *       state,
                const size_t    idx,
                const void*     sample);

    virtual size_t renderpass_get_pass_number(miState *state);

    enum Filtertype {Bilinear, Bicubic};
    virtual bool lookup_filter_color_texture(
            miColor * const     color,
            miState * const     state,
            const miTag         tex,
            Mip_remap &         remap,
            miVector *          coord,
            Filtertype          ft);

    virtual MISLightList *createMISLightList(
        miState         *state,
        miTag           *slist = 0,
        int             n = 0);

    virtual MISLightList *createMISLightList(
        miState         *state,
        Access_bsdf     &bsdf,
        miTag           *slist = 0,
        int             n = 0);

    virtual bool lookup_filter_color_texture(
        miColor * const color,
        miState * const state,
        const miTag             tex,
        Mip_remap &             remap,
        miVector *              coord,
        Filtertype              ft,
        miScalar                blur);
};



class Options {
  public: 

    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) = 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) const = 0;

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

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

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

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

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

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

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

    virtual void release() = 0;
};



class Access_interface {
public:
    Access_interface(int version = mi_ray_interface_version)
        : m_iface (mi_get_shader_interface(version))
    {}

    ~Access_interface()
    {
        m_iface->release();
        m_iface = 0;
    }

    mi::shader_v3::Interface * operator->()
    {
        return m_iface;
    }

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


typedef Access_interface Interface_access;


} // namespace shader_v3


// namespace alias, shaders should use it
namespace shader = shader_v3;

} // namespace mi

#include "shader_framebuffer.h"
#include "shader_output.h"
#include "shader_map.h"
#include "shader_lightlist.h"
#include "shader_sds34.h"
#include "shader_mipremap.h"
#include "shader_importance.h"

#endif // MI_SHADER_IF_H