Mentalray shader for Indexed Framebuffer

make_indexed_framebuffers.mi file

declare shader
geometry "make_indexed_framebuffers"(
string option_block_name;
string fileName;
string render_dir;
integer frame_padding;
integer NoOfBuffers;
)
version 1
apply geometry
end declare

make_indexed_framebuffers.cpp

#define _CRT_SECURE_NO_WARNINGS

#include
#include
#include
#include "shader.h"
#include "geoshader.h"

struct make_indexed_framebuffers
{
miTag option_block_name;
miTag fileName;
miTag render_dir;
int frame_padding;
int NoOfBuffers;
};
typedef struct
{
int index;
char* type;
char* filename;
miBoolean filtering;
char* ext;
char* name;
} fb_args;

char* tag_to_string(miTag tag, char *default_value)
{
char *result = default_value;
if (tag != 0) {
result = (char*)mi_db_access(tag);
mi_db_unpin(tag);
}
return result;
}

int get_frame_number(miState* state, char *padd, int pad)
{
int frame_n = state->camera->frame;
double int_padding = 10;
if(frame_n != 0)
{
double float_padding = 1000000000;
while((int)float_padding > frame_n)
{
int_padding--;
float_padding /= 10;
}
if(int_padding > pad)
pad = (int)int_padding;
}
else
int_padding = 1;

sprintf(padd, "%d", frame_n);

char result[11];
for(int i = 0; i < 11; i++)
result[i] = 0;

for(int i = (int)int_padding; i < pad; i++)
strcat(result, "0");

strcat(result, padd);
strcpy(padd, result);
return 1;
}

int get_render_file_func(miState* state, char *dir, char *name,int pad, char *ext)
{
char frame_num[11];
get_frame_number(state, frame_num, pad);
strcat(dir, "/"); //render_dir + "/"
strcat(dir, name); //add name
strcat(dir, frame_num); //add frame number
strcat(dir, "."); //add dot
strcat(dir, ext); //add format
return 1;
}


/* Get the set of arguments by evaluating parameters: */

void get_indexed_framebuffer_args(
fb_args args[], int count, miState *state,
struct make_indexed_framebuffers *params)
{
// int i_fb = *mi_eval_integer(¶ms->i_fb), i;
char* filename = tag_to_string(*mi_eval_tag(¶ms->fileName), NULL);
char* dirName = tag_to_string(*mi_eval_tag(¶ms->render_dir), NULL);
int padd = *mi_eval_integer(¶ms->frame_padding);
char temp_render_dir_cur_pass[512];
strcpy(temp_render_dir_cur_pass, dirName);
get_render_file_func(state,temp_render_dir_cur_pass,filename,padd,"exr");
char* render_dir_cur_pass = mi_mem_strdup(temp_render_dir_cur_pass);
mi_info("Making %i user framebuffers:", count);
int i;
for (i = 0; i < count; ++i)
{

args[i].index = i;
args[i].type = "rgba_fp";
args[i].filename = render_dir_cur_pass;
args[i].filtering = true;
args[i].ext = "exr";

}
}


/* Shader functions: */

extern "C" DLLEXPORT
int make_indexed_framebuffers_version(void) { return 1; }

extern "C" DLLEXPORT
miBoolean make_indexed_framebuffers (
miTag *result, miState *state, struct make_indexed_framebuffers *params)
{
char* option_block_name = tag_to_string(*mi_eval_tag(¶ms->option_block_name), "opt");
miOptions* options = (miOptions*)(state->options);
mi::shader::Edit_fb framebuffers(state->camera->buffertag);
framebuffers->reset();
int i;
int count = *mi_eval_integer(¶ms->NoOfBuffers);
//if((*mi_eval_integer(¶ms->n_fb)%3) > 0)
//count++;
fb_args* args = (fb_args*)mi_mem_allocate(count * sizeof(fb_args));
get_indexed_framebuffer_args(args, count, state, params);

mi_api_options_begin(mi_mem_strdup(option_block_name));

for (unsigned int i = 0; i < count; ++i)
{
const char* bname;
framebuffers->get_buffername(i,bname);
framebuffers->set(bname, "datatype", args[i].type);
framebuffers->set(bname, "filtering",
args[i].filtering ? true : false);
framebuffers->set(bname, "user", true);
// A framebuffer could be used by output shader and not
// written to file, so check for a filename:
if (args[i].filename && strlen(args[i].filename) > 1)
{
mi_info (" ... writes to %s", args[i].filename);
framebuffers->set(bname, "filename", args[i].filename);
}
}
return miTRUE;
}