void BlenderSession::bake(BL::Object b_object, const string& pass_type, BL::BakePixel pixel_array, int num_pixels, int depth, float result[])
{
ShaderEvalType shader_type = get_shader_type(pass_type);
size_t object_index = ~0;
int tri_offset = 0;
if(shader_type == SHADER_EVAL_UV) {
/* force UV to be available */
Pass::add(PASS_UV, scene->film->passes);
}
if(is_light_pass(shader_type)) {
/* force use_light_pass to be true */
Pass::add(PASS_LIGHT, scene->film->passes);
}
/* create device and update scene */
scene->film->tag_update(scene);
scene->integrator->tag_update(scene);
/* update scene */
sync->sync_camera(b_render, b_engine.camera_override(), width, height);
sync->sync_data(b_v3d, b_engine.camera_override(), &python_thread_state);
/* get buffer parameters */
SessionParams session_params = BlenderSync::get_session_params(b_engine, b_userpref, b_scene, background);
BufferParams buffer_params = BlenderSync::get_buffer_params(b_render, b_scene, b_v3d, b_rv3d, scene->camera, width, height);
/* set number of samples */
session->tile_manager.set_samples(session_params.samples);
session->reset(buffer_params, session_params.samples);
session->update_scene();
/* find object index. todo: is arbitrary - copied from mesh_displace.cpp */
for(size_t i = 0; i < scene->objects.size(); i++) {
if(strcmp(scene->objects[i]->name.c_str(), b_object.name().c_str()) == 0) {
object_index = i;
tri_offset = scene->objects[i]->mesh->tri_offset;
break;
}
}
/* when used, non-instanced convention: object = ~object */
int object = ~object_index;
BakeData *bake_data = scene->bake_init(object, tri_offset, num_pixels);
populate_bake_data(bake_data, pixel_array, num_pixels);
scene->bake(shader_type, bake_data, result);
/* free all memory used (host and device), so we wouldn't leave render
* engine with extra memory allocated
*/
session->device_free();
delete sync;
sync = NULL;
}
static Shader_Param* get_active_params( Program* pgm, GLint* active,
GLenum active_query,
GLenum maxlen_query,
get_active_param_f get,
get_param_location_f location,
int n_bindings,
const char* bindings[] ) {
GLint N; glGetProgramiv( pgm->id, active_query, &N ); check_GL_error;
GLsizei maxlen; glGetProgramiv( pgm->id, maxlen_query, &maxlen ); check_GL_error;
Shader_Param* params = calloc( N, sizeof(Shader_Param) );
for( int i=0; i<N; i++ ) {
GLchar name[ maxlen ];
GLenum type = 0;
GLint size = 0;
// Get name, size, type
get(pgm->id, i, maxlen, NULL, &size, &type, name); check_GL_error;
int binding = indexOf_binding( pgm->id, location,
name,
n_bindings, bindings );
if( binding < 0 ) {
warning( "A binding for shader parameter `%s' was given but is not active",
bindings[i] );
continue;
}
Shader_Param* param = ¶ms[ binding ];
param->name = malloc( maxlen ); strcpy( param->name, name );
param->loc = location( pgm->id, name ); check_GL_error;
param->type = get_shader_type(type, size);
}
*active = N;
return params;
}
int main(int argc, char *argv[]) {
if(argc < 1) {
printf("usage: sdump src-directory\n");
}
else {
printf("Opening directory '%s'.\n", argv[1]);
/*
* Open our specified directory.
*/
DIR *dir = opendir(argv[1]);
if(dir != NULL) {
/*
* Make this directory our CWD so our
* output files will end up here.
*/
chdir(argv[1]);
/*
* Loop over a listing of the directory.
*/
struct dirent *ent = NULL;
while((ent = readdir(dir)) != NULL) {
/*
* Calculate our necessary array length.
*/
size_t dn_length = strlen(argv[1]);
size_t fn_length = strlen(argv[1]);
size_t fp_length = dn_length + fn_length + 1;
/*
* Build the file full path for use with stat.
* Make the array long enough to be null terminated.
* Note that snprintf NULL terminates the data for us.
*/
char full_path[fp_length + 1];
snprintf(full_path, fp_length, "%s%s%s", argv[1], DIR_STR, ent->d_name);
/*
* Get the status of the file.
*/
struct stat file_stat;
stat(full_path, &file_stat);
/*
* Check the mode member of the file status struct.
* This tells us what type of file the file is.
* Skip all directories in the current directory we are reading.
*/
if(!S_ISDIR(file_stat.st_mode)) {
/*
* The strtok call in get_shader_type
* in-place substitues '.' with '\0' so
* we should copy that string so we do not
* modify the stat struct data.
*/
char tokenized_name[64];
snprintf(tokenized_name, 64, "%s", ent->d_name);
unsigned int shader_type = get_shader_type(tokenized_name);
/*
* Ensure we only read shader files.
*/
if(shader_type != NOT_SHADER) {
printf("Reading shader '%s'.\n", full_path);
char base_name[64];
snprintf(base_name, 64, "%s", ent->d_name);
get_base_name(base_name);
if(base_name != NULL) {
char file_name[64];
snprintf(file_name, 64, "%s%s.h", base_name, SHADER_NAMES_LOWER[shader_type]);
/*
* Write out our compiled shader to a header.
*/
FILE *header_fp = fopen(file_name, "wb");
if(header_fp != NULL) {
char obj_name[64];
upper(base_name, obj_name);
time_t raw_time;
time(&raw_time);
struct tm *tm_ptr = localtime(&raw_time);
char time_str[64];
strftime(time_str, 64, "%c", tm_ptr);
const char *const shader_type_name = SHADER_NAMES_UPPER[shader_type];
fprintf(header_fp, HEADER_FMT_TOP, obj_name, shader_type_name,
obj_name, shader_type_name, time_str, obj_name, shader_type_name);
dump_shader(full_path, header_fp);
fprintf(header_fp, HEADER_FMT_BOT);
fclose(header_fp);
}
free(base_name);
}
}
}
}
}
else {
perror("Could not open directory");
}
}
return 0;
}
void BlenderSession::bake(BL::Object b_object, const string& pass_type, const int object_id, BL::BakePixel pixel_array, const size_t num_pixels, const int /*depth*/, float result[])
{
ShaderEvalType shader_type = get_shader_type(pass_type);
size_t object_index = OBJECT_NONE;
int tri_offset = 0;
/* Set baking flag in advance, so kernel loading can check if we need
* any baking capabilities.
*/
scene->bake_manager->set_baking(true);
/* ensure kernels are loaded before we do any scene updates */
session->load_kernels();
if(session->progress.get_cancel())
return;
if(shader_type == SHADER_EVAL_UV) {
/* force UV to be available */
Pass::add(PASS_UV, scene->film->passes);
}
if(BakeManager::is_light_pass(shader_type)) {
/* force use_light_pass to be true */
Pass::add(PASS_LIGHT, scene->film->passes);
}
/* create device and update scene */
scene->film->tag_update(scene);
scene->integrator->tag_update(scene);
/* update scene */
sync->sync_camera(b_render, b_engine.camera_override(), width, height);
sync->sync_data(b_render,
b_v3d,
b_engine.camera_override(),
width, height,
&python_thread_state,
b_rlay_name.c_str());
/* get buffer parameters */
SessionParams session_params = BlenderSync::get_session_params(b_engine, b_userpref, b_scene, background);
BufferParams buffer_params = BlenderSync::get_buffer_params(b_render, b_v3d, b_rv3d, scene->camera, width, height);
scene->bake_manager->set_shader_limit((size_t)b_engine.tile_x(), (size_t)b_engine.tile_y());
/* set number of samples */
session->tile_manager.set_samples(session_params.samples);
session->reset(buffer_params, session_params.samples);
session->update_scene();
/* find object index. todo: is arbitrary - copied from mesh_displace.cpp */
for(size_t i = 0; i < scene->objects.size(); i++) {
if(strcmp(scene->objects[i]->name.c_str(), b_object.name().c_str()) == 0) {
object_index = i;
tri_offset = scene->objects[i]->mesh->tri_offset;
break;
}
}
/* when used, non-instanced convention: object = ~object */
int object = ~object_index;
BakeData *bake_data = scene->bake_manager->init(object, tri_offset, num_pixels);
populate_bake_data(bake_data, object_id, pixel_array, num_pixels);
/* set number of samples */
session->tile_manager.set_samples(session_params.samples);
session->reset(buffer_params, session_params.samples);
session->update_scene();
session->progress.set_update_callback(function_bind(&BlenderSession::update_bake_progress, this));
scene->bake_manager->bake(scene->device, &scene->dscene, scene, session->progress, shader_type, bake_data, result);
/* free all memory used (host and device), so we wouldn't leave render
* engine with extra memory allocated
*/
session->device_free();
delete sync;
sync = NULL;
}
