void Render::handle_close_event(int result)
{
int format_error = 0;
const int debug = 0;
if(!result)
{
if(debug) printf("Render::handle_close_event %d\n", __LINE__);
// Check the asset format for errors.
FormatCheck format_check(asset);
if(debug) printf("Render::handle_close_event %d\n", __LINE__);
format_error = format_check.check_format();
if(debug) printf("Render::handle_close_event %d\n", __LINE__);
}
PRINT_TRACE
save_defaults(asset);
PRINT_TRACE
mwindow->save_defaults();
PRINT_TRACE
if(!format_error && !result)
{
if(debug) printf("Render::handle_close_event %d\n", __LINE__);
if(!result) start_render();
if(debug) printf("Render::handle_close_event %d\n", __LINE__);
}
PRINT_TRACE
}
void Render::start_batches(ArrayList<BatchRenderJob*> *jobs)
{
if(!thread->running())
{
mode = Render::BATCH;
this->jobs = jobs;
completion->reset();
start_render();
}
}
int main(int argc, char *argv[])
{
Globals globales;
clock_t render_ticks;
//tInitDataTicks,
//tCleanDataTicks;
std::string scene_desc_file,
output_file,
output_file_dir,
output_file_path;
// Redirigimos std::clog a un archivo de texto.
CLog_Redir clogredir("log.txt");
// Y configuramos el logger.
LOGCFG.headers = true;
LOGCFG.level = DEBUG;
bool end_status;
LOG() << "main - Comprobando argumentos.";
if(argc > 1) {
for(int i = 1; i < argc; ++i) {
if(argv[i][0] == '-') { // Procesamos las opciones.
if(std::string(argv[i]) == "-h" || std::string(argv[i]) == "--help") {
muestra_ayuda(argv[0]);
return 0;
}
else if(std::string(argv[i]) == "-t" || std::string(argv[i]) == "--test") {
globales.options |= Global_opts::kglb_do_test;
}
else if(std::string(argv[i]) == "-s" || std::string(argv[i]) == "--showaabb") {
globales.options |= Global_opts::kglb_show_aabb;
}
else if(std::string(argv[i]) == "-c" || std::string(argv[i]) == "--contrib") {
globales.options |= Global_opts::kglb_do_contrib;
}
}
else {
// Se proporciona fichero, anulamos el test.
globales.options &= ~Global_opts::kglb_do_test;
if(scene_desc_file.empty())
// Fichero de escena a renderizar
scene_desc_file.assign(argv[i]);
else
// Fichero donde guardar la imagen
output_file.assign(argv[i]);
}
}
}
LOG() << "main - ... hecho.";
if((scene_desc_file.empty() || (argc < 2)) && !(globales.options & Global_opts::kglb_do_test)) {
muestra_ayuda(argv[0]);
return 0;
}
else {
if(globales.options & Global_opts::kglb_do_test) {
Test test;
end_status = test.launch_test();
}
else {
LOG() << "main - Leyendo archivo...";
end_status = parse_file(&globales, scene_desc_file);
LOG() << "main - ... hecho.";
if(end_status) {
render_ticks = clock();
// Start render loop
if(globales.options & Global_opts::kglb_do_contrib)
end_status = start_render_v2(&globales);
else
end_status = start_render(&globales);
render_ticks = clock() - render_ticks;
print_time("\n\nRender Time: ", static_cast<float>(render_ticks)/CLOCKS_PER_SEC);
print_statistics();
if(output_file.empty()) {
std::string temp;
// Averiguamos el nombre del fichero.
image_file_name(scene_desc_file, temp);
// Añadimos la extension.
output_file = temp + ".ppm";
output_file_dir = temp + "_dir.ppm";
output_file_path = temp + "_path.ppm";
}
if(globales.options & Global_opts::kglb_do_contrib)
globales.image->create_final_img();
globales.image->gamma_correct(2.2f);
save_file(&globales, output_file, 0);
if(globales.options & Global_opts::kglb_do_contrib) {
save_file(&globales, output_file_dir, 1);
save_file(&globales, output_file_path, 2);
}
}
}
}
if(end_status)
return 0;
else
return -1;
}
bool RenderChain::render(const void *data,
unsigned width, unsigned height, unsigned pitch, unsigned rotation)
{
start_render();
unsigned current_width = width, current_height = height;
unsigned out_width = 0, out_height = 0;
convert_geometry(passes[0].info, out_width, out_height,
current_width, current_height, final_viewport);
blit_to_texture(data, width, height, pitch);
// Grab back buffer.
LPDIRECT3DSURFACE back_buffer;
dev->GetRenderTarget(0, &back_buffer);
// In-between render target passes.
for (unsigned i = 0; i < passes.size() - 1; i++)
{
Pass &from_pass = passes[i];
Pass &to_pass = passes[i + 1];
LPDIRECT3DSURFACE target;
to_pass.tex->GetSurfaceLevel(0, &target);
dev->SetRenderTarget(0, target);
convert_geometry(from_pass.info,
out_width, out_height,
current_width, current_height, final_viewport);
// Clear out whole FBO.
D3DVIEWPORT viewport = {0};
viewport.Width = to_pass.info.tex_w;
viewport.Height = to_pass.info.tex_h;
viewport.MinZ = 0.0f;
viewport.MaxZ = 1.0f;
dev->SetViewport(&viewport);
dev->Clear(0, 0, D3DCLEAR_TARGET, 0, 1, 0);
viewport.Width = out_width;
viewport.Height = out_height;
set_viewport(viewport);
set_vertices(from_pass,
current_width, current_height,
out_width, out_height,
out_width, out_height, 0);
render_pass(from_pass, i + 1);
current_width = out_width;
current_height = out_height;
target->Release();
}
// Final pass
dev->SetRenderTarget(0, back_buffer);
Pass &last_pass = passes.back();
convert_geometry(last_pass.info,
out_width, out_height,
current_width, current_height, final_viewport);
set_viewport(final_viewport);
set_vertices(last_pass,
current_width, current_height,
out_width, out_height,
final_viewport.Width, final_viewport.Height,
rotation);
render_pass(last_pass, passes.size());
frame_count++;
back_buffer->Release();
end_render();
set_shaders(fStock, vStock);
set_cg_mvp(vStock, final_viewport.Width, final_viewport.Height, 0);
return true;
}
