/// main: load scene, initialize acceleration, raytraces scene, saves image
int main(int argc, char** argv) {
parse_args(argc,argv);
Serializer::read_json(scene, filename_scene);
if(scene->raytrace_opts) opts = *scene->raytrace_opts;
if(scene->distribution_opts) disttrace_opts = *scene->distribution_opts;
if(scene->pathtrace_opts) pathtrace_opts = *scene->pathtrace_opts;
// command-line options override settings in json
if(resolution > 0) {
opts.res = resolution;
disttrace_opts.res = resolution;
pathtrace_opts.res = resolution;
}
if(samples > 0) {
opts.samples = samples;
disttrace_opts.samples = samples;
pathtrace_opts.samples = samples;
}
scene_tesselation_init(scene,false,0,false);
//scene_animation_snapshot(scene,opts.time);
sample_lights_init(scene->lights);
if(opts.cameralights) scene_cameralights_update(scene,opts.cameralights_dir, opts.cameralights_col);
intersect_scene_accelerate(scene);
auto w = camera_image_width(scene->camera, opts.res);
auto h = camera_image_height(scene->camera, opts.res);
image<vec3f> img;
init_buffers(w, h);
auto samples = (pathtrace ? pathtrace_opts.samples : (distribution ? disttrace_opts.samples : opts.samples ) );
// for debug:
for(auto s = 0; s < samples; s ++) {
printf("Pass: %02d/%02d\n", s, samples);
render_pass(img);
if(progressive && s < samples-1) {
trace_image_buffer.get_image(img);
imageio_write_png(filename_image, img, false);
}
}
trace_image_buffer.get_image(img);
imageio_write_png(filename_image, img, false);
}
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;
}
int fs_emu_xml_shader_render(int texture, int texture_width,
int texture_height, int input_width, int input_height,
int output_width, int output_height, float x1, float y1,
float x2, float y2, int render_textured_side, float alpha) {
if (!fs_emu_xml_shader_is_enabled()) {
return 0;
}
g_x1 = x1;
g_x2 = x2;
g_y1 = y1;
g_y2 = y2;
g_alpha = alpha;
g_render_textured_side = render_textured_side;
fs_gl_blending(0);
fs_gl_texturing(1);
fs_gl_color4f(1.0, 1.0, 1.0, 1.0);
// Let the current input size be the dimensions of the video-frame
// generated by the host application.
g_cur_input_w = input_width;
g_cur_input_h = input_height;
// Calculate the current texture size as a suitable set of dimensions
// larger than the current input size.
g_cur_texture_w = texture_width;
g_cur_texture_h = texture_height;
// Calculate the final output size as the dimensions of the region of the
// back-buffer where the output will be displayed to the user, measured
// in pixels.
g_final_output_w = output_width;
g_final_output_h = output_height;
// Let requires implicit pass be False.
g_requires_implicit_pass = 0;
// Construct the current texture, whose dimensions are the current
// texture size, and draw the video-frame generated by the host
// application into it.
g_cur_texture = texture;
debug_printf("\n\n\n\n\n");
debug_printf("cur tex %d\n", g_cur_texture);
g_orig_texture = g_cur_texture;
g_orig_texture_w = g_cur_texture_w;
g_orig_texture_h = g_cur_texture_h;
g_orig_input_w = g_cur_input_w;
g_orig_input_h = g_cur_input_h;
debug_printf("final output: %d %d\n", g_final_output_w, g_final_output_h);
debug_printf(" input: %d %d\n", g_cur_input_w, g_cur_input_h);
debug_printf(" texture: %d %d\n", g_cur_texture_w, g_cur_texture_h);
// For each shader pass in the list of shader passes...
GList *link = g_active_shader->passes;
int first = 1;
while (link) {
shader_pass *pass = link->data;
render_pass(pass, first, link->next == NULL);
first = 0;
link = link->next;
}
// If requires implicit pass is True
if (g_requires_implicit_pass) {
debug_printf("implicit pass, cur tex %d %d %d\n", g_cur_texture,
g_cur_texture_w, g_cur_texture_h);
// Render a quad, textured with the current texture, with a vertex
// at each corner of the final output size.
float s2 = (float) g_cur_input_w / (float) g_cur_texture_w;
float t2 = (float) g_cur_input_h / (float) g_cur_texture_h;
fs_gl_bind_texture(g_cur_texture);
render_quad(s2, 0.0, t2, 0, 1, 0);
}
CHECK_GL_ERROR();
g_frame_count++;
glActiveTexture(GL_TEXTURE1);
glBindTexture(GL_TEXTURE_2D, 0);
glActiveTexture(GL_TEXTURE0);
CHECK_GL_ERROR();
return 1;
}
void RenderMeshComponent::AddFromRawData(corgi::EntityRef& entity,
const void* raw_data) {
auto rendermesh_def = static_cast<const RenderMeshDef*>(raw_data);
// You need to call asset_manager before you can add from raw data,
// otherwise it can't load up new meshes!
assert(asset_manager_ != nullptr);
assert(rendermesh_def->source_file() != nullptr);
assert(rendermesh_def->shader() != nullptr);
RenderMeshData* rendermesh_data = AddEntity(entity);
rendermesh_data->mesh_filename = rendermesh_def->source_file()->c_str();
rendermesh_data->shader_filename = rendermesh_def->shader()->c_str();
rendermesh_data->mesh =
asset_manager_->LoadMesh(rendermesh_def->source_file()->c_str());
assert(rendermesh_data->mesh != nullptr);
// Allocate the array to hold shader default pose's transforms.
assert(rendermesh_data->shader_transforms == nullptr);
const uint8_t num_shader_transforms =
rendermesh_data->mesh->num_shader_bones();
rendermesh_data->num_shader_transforms = num_shader_transforms;
if (num_shader_transforms > 0) {
rendermesh_data->shader_transforms =
new mathfu::AffineTransform[num_shader_transforms];
for (uint8_t i = 0; i < num_shader_transforms; ++i) {
rendermesh_data->shader_transforms[i] = mathfu::kAffineIdentity;
}
}
rendermesh_data->shader =
asset_manager_->LoadShader(rendermesh_def->shader()->c_str());
assert(rendermesh_data->shader != nullptr);
rendermesh_data->visible = rendermesh_def->visible();
rendermesh_data->default_pose = rendermesh_def->default_pose();
rendermesh_data->pass_mask = 0;
if (rendermesh_def->render_pass() != nullptr) {
for (size_t i = 0; i < rendermesh_def->render_pass()->size(); i++) {
int render_pass = rendermesh_def->render_pass()->Get(i);
assert(render_pass < RenderPass_Count);
rendermesh_data->pass_mask |= 1 << render_pass;
}
} else {
// Anything unspecified is assumed to be opaque.
rendermesh_data->pass_mask = (1 << RenderPass_Opaque);
}
if (rendermesh_def->culling() != nullptr) {
for (size_t i = 0; i < rendermesh_def->culling()->size(); i++) {
int culling_test = rendermesh_def->culling()->Get(i);
assert(culling_test < CullingTest_Count);
rendermesh_data->culling_mask |= 1 << culling_test;
}
}
// TODO: Load this from a flatbuffer file instead of setting it.
rendermesh_data->tint = mathfu::kOnes4f;
}
