main.cpp

Go to the documentation of this file.

/*
    toxic - A Global Illumination Renderer
    Copyright (C) 2003-2004 Francois Beaune
    Contact: http://toxicengine.sourceforge.net/

    This file is part of toxic.

    toxic is free software; you can redistribute it and/or modify
    it under the terms of the GNU General Public License as published by
    the Free Software Foundation; either version 2 of the License, or
    (at your option) any later version.

    toxic is distributed in the hope that it will be useful,
    but WITHOUT ANY WARRANTY; without even the implied warranty of
    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
    GNU General Public License for more details.

    You should have received a copy of the GNU General Public License
    along with toxic; if not, write to the Free Software
    Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
*/

// Guess the home path in Windows version in Release mode.
#ifdef _WIN32
#ifndef _DEBUG
#define GUESS_HOME_PATH
#endif  // !_DEBUG
#endif  // _WIN32

#include "clparser.h"
#include "common/math/mt19937rng.h"
#include "common/math/real.h"   // sheep::sq<>()
#ifdef GUESS_HOME_PATH
#include "common/misc/apppath.h"
#endif  // GUESS_HOME_PATH
#include "common/misc/consoleprogressmonitor.h"
#include "common/misc/minmax.h"
#include "common/misc/stringutils.h"
#include "renderer/causticsphotontracer.h"
#include "renderer/context.h"
#include "renderer/framebuffer.h"
#include "renderer/globalphotontracer.h"
#include "renderer/globals.h"
#include "renderer/icamera.h"
#ifdef _DEBUG
#include "renderer/photon.h"
#endif  // _DEBUG
#include "renderer/photonmap.h"
#include "renderer/renderer.h"
#include "renderer/scene.h"
#include "renderer/settings.h"
#include "renderer/statistics.h"
#include "renderer/utilities.h"
#include "driversettings.h"
#include "driversettingswrapper.h"
#include "error.h"
#include "helpers.h"
#include "scenebuilder.h"
#include "scenesettingswrapper.h"
#include "version.h"

#ifdef ENABLE_MULTITHREADING
#pragma warning(disable : 4275)
#pragma warning(disable : 4251)

#include <boost/thread/mutex.hpp>
#include <boost/thread/thread.hpp>
#endif  // ENABLE_MULTITHREADING

#include <IL/il.h>
#include <IL/ilu.h>

#include <cassert>
#include <cstdio>
#include <cstdlib>  // std::exit(), EXIT_FAILURE, EXIT_SUCCESS
#include <iostream>
#include <sstream>
#include <string>

using namespace sheep;
using namespace std;
using namespace toxic;

namespace { 
    void print_disclaimer() {
        cout << "toxic - A Global Illumination Renderer" << endl;
        cout << "Copyright (C) 2003-2004 Francois Beaune" << endl << endl;
        cout << "Visit http://toxicengine.sourceforge.net/ for more information." << endl;
        cout << endl;
    }

    string get_home_path() {
#ifdef GUESS_HOME_PATH
        string path = StringUtils::GetPath(GetApplicationPath());

        // toxic binary must be located in the bin\ directory.
        const string bin_path = "bin\\";

        // Issue an error message if this is not the case.
        if(StringUtils::CompareNoCase(path.substr(path.size() - bin_path.size()), "bin\\")) {
            cerr << Error << "toxic is not installed correctly. Please reinstall it." << endl;
            exit(EXIT_FAILURE);
        }

        // Compute the home path by removing the bin\ suffix
        path = path.substr(0, path.size() - bin_path.size());

        return path;
#else
        const char *home_env = getenv("TOXICHOME");

        if(!home_env) {
            cerr << Warning << "'TOXICHOME' environment variable not set." << endl;
            return "./";
        }

        return StringUtils::NormalizePath(home_env);
#endif  // GUESS_HOME_PATH
    }

    void load_settings(DriverSettingsWrapper *driver_settings,
                       SceneSettingsWrapper *scene_settings,
                       const string &home_path)
    {
        assert(driver_settings);
        assert(scene_settings);

        string driver_settings_file =
            driver_settings->m_settings_files.m_driver_settings_file;

        if(driver_settings_file.size() == 0) {
            driver_settings_file = home_path + "settings/toxicsettings.xml";
        }

        // Load driver settings.
        driver_settings->Load(driver_settings_file, home_path);

        // Load scene settings.
        scene_settings->Load(
            driver_settings->m_settings_files.m_scene_settings_file,
            home_path
        );
    }

    void print_statistics(const Statistics &statistics) {
        Indenter indenter;

        cout << indenter() << "Rendering Statistics:" << endl;
        indenter.Indent();

        // Pixels.

        cout << indenter() << "Pixels" << endl;
        indenter.Indent();

        cout << indenter() << "Rendered Pixels: "
            << ConvertNumberToString(statistics.m_total_pixels)
            << endl;

        indenter.Unindent();

        // Photons.

        cout << indenter() << "Photons" << endl;
        indenter.Indent();

        cout << indenter() << "Photons in Global Photon Map: "
            << ConvertNumberToString(statistics.m_gpm_photons)
            << endl;
        cout << indenter() << "Photons in Caustics Photon Map: "
            << ConvertNumberToString(statistics.m_cpm_photons)
            << endl;

        indenter.Unindent();

        // Rays.

        cout << indenter() << "Rays" << endl;
        indenter.Indent();

        const int64 total_rays_cast = statistics.ComputeTotalRays();

        cout << indenter() << "Total Rays Cast: "
            << ConvertNumberToString(total_rays_cast)
            << endl;
        indenter.Indent();
        cout << indenter() << "Primary Rays: "
            << ConvertNumberToString(statistics.m_primary_rays)
            << " ("
            << Percentage(statistics.m_primary_rays, total_rays_cast)
            << ')' << endl;
        cout << indenter() << "Secondary Rays: "
            << ConvertNumberToString(statistics.m_secondary_rays)
            << " ("
            << Percentage(statistics.m_secondary_rays, total_rays_cast)
            << ')' << endl;
        cout << indenter() << "Shadow Rays: "
            << ConvertNumberToString(statistics.m_shadow_rays)
            << " ("
            << Percentage(statistics.m_shadow_rays, total_rays_cast)
            << ')' << endl;
        cout << indenter() << "Primary Final Gathering Rays: "
            << ConvertNumberToString(statistics.m_primary_final_gathering_rays)
            << " ("
            << Percentage(statistics.m_primary_final_gathering_rays, total_rays_cast)
            << ')' << endl;
        cout << indenter() << "Secondary Final Gathering Rays: "
            << ConvertNumberToString(statistics.m_secondary_final_gathering_rays)
            << " ("
            << Percentage(statistics.m_secondary_final_gathering_rays, total_rays_cast)
            << ')' << endl;
        indenter.Unindent();

        cout << indenter() << "Average Rays per Pixel: "
            << Ratio(total_rays_cast, statistics.m_total_pixels)
            << endl;
        indenter.Indent();
        cout << indenter() << "Primary Rays: "
            << Ratio(statistics.m_primary_rays, statistics.m_total_pixels)
            << endl;
        cout << indenter() << "Secondary Rays: "
            << Ratio(statistics.m_secondary_rays, statistics.m_total_pixels)
            << endl;
        cout << indenter() << "Shadow Rays: "
            << Ratio(statistics.m_shadow_rays, statistics.m_total_pixels)
            << endl;
        cout << indenter() << "Primary Final Gathering Rays: "
            << Ratio(statistics.m_primary_final_gathering_rays, statistics.m_total_pixels)
            << endl;
        cout << indenter() << "Secondary Final Gathering Rays: "
            << Ratio(statistics.m_secondary_final_gathering_rays, statistics.m_total_pixels)
            << endl;
        indenter.Unindent();

        indenter.Unindent();

        // Intersections.

        cout << indenter() << "Intersections" << endl;
        indenter.Indent();

        cout << indenter() << "Intersections Tested: "
            << ConvertNumberToString(statistics.m_tested_intersections)
            << endl;
        cout << indenter() << "Intersections Found: "
            << ConvertNumberToString(statistics.m_intersections_found)
            << endl;
        cout << indenter() << "Found/Tested Intersections Ratio: "
            << Percentage(statistics.m_intersections_found, statistics.m_tested_intersections)
            << endl;

        indenter.Unindent();
    }
}

#ifdef ENABLE_MULTITHREADING

boost::mutex io_mutex;

void foo() {
    for(int i = 0; i < 100; ++i) {
        boost::mutex::scoped_lock lock(io_mutex);
        cerr << '*';
    }
}

class RenderingThread {
public:
    RenderingThread(Renderer *renderer, const Context &context) :
        m_renderer(renderer),
        m_context(context)
    {
        assert(renderer);
        assert(progmon);
    }

    void operator()() const {
        while(!m_renderer->IsRenderComplete()) {
            m_renderer->RenderNextPixel(m_context);
        }
    }

private:
    Renderer *m_renderer;
    const Context &m_context;
};

class ProgressMonitoringThread {
public:
    void operator()() const {
        while(true) {
        }
    }

private:

    bool is_render_complete() const {
        for(int i = 0; i < nthreads; ++i) {
            if(IsRenderComplete
        }
    }
};

#endif  // ENABLE_MULTITHREADING

int main(int argc, char *argv[]) {
    //!\todo Create a DevILManager() following the example of XercesManager().
    ilInit();
    iluInit();

    print_disclaimer();

    // Print version informations.
    cout << "Running toxic version " << VERSION << ", build " << BUILD_NUMBER << endl << endl;

#ifdef _DEBUG
    cout << "DEBUG: Size of the Photon structure: "
        << sizeof(Photon)
        << " bytes"
        << endl << endl;
#endif  // _DEBUG

    const string home_path = get_home_path();

#ifdef _DEBUG
    cout << "DEBUG: Home path: " << home_path << endl << endl;
#endif  // _DEBUG

    DriverSettingsWrapper driver_settings;
    SceneSettingsWrapper scene_settings;

    // Parse the command line.
    CLParser(&driver_settings).Parse(argc, argv);

    // Load settings.
    load_settings(&driver_settings, &scene_settings, home_path);

    // Check settings consistency.
    driver_settings.CheckConsistency();
    scene_settings.CheckConsistency();

    // Print settings.
    driver_settings.Print(cout);
    cout << endl;
    scene_settings.Print(cout);
    cout << endl;

    ConsoleProgressMonitor progmon;
    stringstream ss;

    // Count the number of task to complete.
    int task_count = 0;
    ++task_count;       // initialize framebuffer
    ++task_count;       // initialize scene
    if(scene_settings.m_rendering.m_components.m_indirect_lighting.m_enabled)
        ++task_count;   // build/load global photon map
    if(scene_settings.m_rendering.m_components.m_caustics.m_enabled)
        ++task_count;   // build/load caustics photon map
    if(driver_settings.m_primary_output.m_enabled)
        ++task_count;   // generate primary output

    int current_task = 0;

    // Create the Context object.
    MT19937RNG rng;
    Statistics statistics;
    Context context(&rng, &scene_settings, &statistics);

    // Create the Renderer object.
    Renderer renderer;

    cout << ++current_task << '/' << task_count << ". Initializing framebuffer" << endl;

    // Allocate memory for the framebuffer.
    cout << "     * Memory allocation" << flush;
    Framebuffer *framebuffer = new Framebuffer(
        driver_settings.m_primary_output.m_width,
        driver_settings.m_primary_output.m_height,
        Framebuffer::RGB_FLOAT_32
    );
    cout << " [" << ConvertSizeToString(framebuffer->GetSizeInMemory(), true)
        << " allocated]." << endl;

    // Initialize (clear) the framebuffer.
    cout << "     * Memory initialization" << flush;
    framebuffer->Clear();
    cout << '.' << endl;

    // Assign the framebuffer to the renderer.
    renderer.SetFramebuffer(framebuffer);

    // Restrict the render area on demand.
    if(scene_settings.m_output.m_render_area.m_enabled) {
        renderer.SetRenderArea(
            scene_settings.m_output.m_render_area.m_x0,
            scene_settings.m_output.m_render_area.m_y0,
            scene_settings.m_output.m_render_area.m_x1,
            scene_settings.m_output.m_render_area.m_y1
        );
    }

    // Load the input file.

    cout << ++current_task << '/' << task_count << ". Initializing scene" << endl;

    SceneBuilder *scene_builder;
    const Scene *scene;
    const ICamera *camera;

    bool successful = false;

    try {
        scene_builder = new SceneBuilder(
            context,
            framebuffer,
            driver_settings.m_input_files.m_scene_file,
            home_path,
            &progmon
        );

        scene = scene_builder->GetScene().release();
        camera = scene_builder->GetCamera().release();

        successful = true;
    }
    catch(const SceneBuilder::ParseErrorException &e) {
        cerr << Error << e.m_message << endl;
    }
    catch(const SceneBuilder::LoadErrorException &e) {
        cerr << Error << e.m_message << endl;
    }
    catch(...) {
        cerr << Error << "Unknown exception." << endl;
    }

    if(!successful) {
        cerr << Error << "Could not load the scene file '"
            << driver_settings.m_input_files.m_scene_file
            << "'." << endl;
        return EXIT_FAILURE;
    }

    renderer.SetScene(scene);
    renderer.SetCamera(camera);

    cout << "     * Scene composition" << endl;
    cout << "         Objects: " << scene->GetRootObject()->GetObjectCount() << endl;
    cout << "         Light sources: " << scene->GetLightCount() << endl;

    PhotonMap *global_pm = 0;

    if(scene_settings.m_rendering.m_components.m_indirect_lighting.m_enabled) {
        if(driver_settings.m_global_photon_map.m_op == DriverSettings::LOAD_PM) {
            // Load the global photon map from disk.

            ss.str("");
            ss << ++current_task << '/' << task_count << ". Reading GPM from file "
                << driver_settings.m_global_photon_map.m_file;
            progmon.Reset(ss.str());

            global_pm = PhotonMap::CreateFromFile(
                driver_settings.m_global_photon_map.m_file,
                &progmon
            );

            if(!global_pm) {
                cerr << Error << "Failed to read from file '"
                    << driver_settings.m_global_photon_map.m_file << "'." << endl;
                return EXIT_FAILURE;
            }

            statistics.m_gpm_photons = global_pm->GetPhotonCount();
            // 'statistics.m_photon_rays' is not updated.
        } else {
            // Build the global photon map from scratch.

            cout << ++current_task << '/' << task_count << ". Building global photon map (GPM)" << endl;

            // Allocate memory for the global photon map.
            global_pm = new PhotonMap();

            // Build the global photon map by tracing photons through the scene.
            progmon.Reset("     * Photon tracing");
            GlobalPhotonTracer().BuildPhotonMap(
                context,
                global_pm,
                scene,
                scene_settings.m_rendering.m_components.m_indirect_lighting.m_photon_tracing.m_photons,
                &progmon
            );

            // Balance the global photon map.
            cout << "     * Photon map balancing" << flush;
            global_pm->Balance();
            cout << '.' << endl;

            // Precompute radiances if necessary.
            if(scene_settings.m_rendering.m_components.m_indirect_lighting.m_radiance_precomp.m_enabled) {
#ifdef ENABLE_RADIANCES_PRECOMPUTATION
                progmon.Reset("     * Radiances precomputation");
                global_pm->PrecomputeRadiances(
                    scene_settings.m_rendering.m_components.m_indirect_lighting.m_radiance_precomp.m_spacing,
                    scene_settings.m_rendering.m_components.m_indirect_lighting.m_radiance_est.m_max_distance,
                    scene_settings.m_rendering.m_components.m_indirect_lighting.m_radiance_est.m_max_photons,
                    &progmon
                );
#else
                cout << "     * Radiances precomputation not available. Using standard radiance estimate." << endl;
#endif  // ENABLE_RADIANCES_PRECOMPUTATION
            }
        }

        // Display some early statistics.
        cout << "     * Early statistics" << endl;
        cout << "         Allocated memory: "
            << ConvertSizeToString(global_pm->GetSizeInMemory(), true)
            << endl;
        if(driver_settings.m_global_photon_map.m_op != DriverSettings::LOAD_PM) {
            cout << "         Emitted photons: "
                << ConvertNumberToString(scene_settings.m_rendering.m_components.m_indirect_lighting.m_photon_tracing.m_photons)
                << endl;
        }
        cout << "         Stored photons: "
            << ConvertNumberToString(statistics.m_gpm_photons);
        if(driver_settings.m_global_photon_map.m_op != DriverSettings::LOAD_PM) {
            cout << " ("
                << Percentage(statistics.m_gpm_photons, scene_settings.m_rendering.m_components.m_indirect_lighting.m_photon_tracing.m_photons)
                << ')';
        }
        cout << endl;

        if(driver_settings.m_global_photon_map.m_op == DriverSettings::BUILD_AND_SAVE_PM) {
            // Save the global photon map to disk.

            ss.str("");
            ss << "     * Writing GPM to file "
                << driver_settings.m_global_photon_map.m_file;
            progmon.Reset(ss.str());

            if(!global_pm->WriteToFile(
                driver_settings.m_global_photon_map.m_file,
                &progmon))
            {
                cerr << Error << "Failed to write to file '"
                    << driver_settings.m_global_photon_map.m_file << "'." << endl;
                //return EXIT_FAILURE;
            }
        }

        // Assign the global photon map to the renderer.
        renderer.SetGlobalPhotonMap(global_pm);
    }

    PhotonMap *caustics_pm = 0;

    if(scene_settings.m_rendering.m_components.m_caustics.m_enabled) {
        if(driver_settings.m_caustics_photon_map.m_op == DriverSettings::LOAD_PM) {
            // Load the caustics photon map from disk.

            ss.str("");
            ss << ++current_task << '/' << task_count << ". Reading CPM from file "
                << driver_settings.m_caustics_photon_map.m_file;
            progmon.Reset(ss.str());

            caustics_pm = PhotonMap::CreateFromFile(
                driver_settings.m_caustics_photon_map.m_file,
                &progmon
            );

            if(!caustics_pm) {
                cerr << Error << "Failed to read from file '"
                    << driver_settings.m_caustics_photon_map.m_file << "'." << endl;
                return EXIT_FAILURE;
            }

            statistics.m_cpm_photons = caustics_pm->GetPhotonCount();
            // 'statistics.m_photon_rays' is not updated.
        } else {
            // Build the caustics photon map from scratch.

            cout << ++current_task << '/' << task_count << ". Building caustics photon map (CPM)" << endl;

            // Allocate memory for the caustics photon map.
            caustics_pm = new PhotonMap();

            // Build the caustics photon map by tracing photons through the scene.
            progmon.Reset("     * Photon tracing");
            CausticsPhotonTracer().BuildPhotonMap(
                context,
                caustics_pm,
                scene,
                scene_settings.m_rendering.m_components.m_caustics.m_photon_tracing.m_photons,
                &progmon
            );

            cout << "     * Allocated memory: "
                << ConvertSizeToString(caustics_pm->GetSizeInMemory(), true)
                << "." << endl;

            // Balance the caustics photon map.
            cout << "     * Photon map balancing" << flush;
            caustics_pm->Balance();
            cout << '.' << endl;
        }

        // Display some early statistics.
        cout << "     * Early statistics" << endl;
        cout << "         Allocated memory: "
            << ConvertSizeToString(caustics_pm->GetSizeInMemory(), true)
            << endl;
        if(driver_settings.m_caustics_photon_map.m_op != DriverSettings::LOAD_PM) {
            cout << "         Emitted photons: "
                << ConvertNumberToString(scene_settings.m_rendering.m_components.m_caustics.m_photon_tracing.m_photons)
                << endl;
        }
        cout << "         Stored photons: "
            << ConvertNumberToString(statistics.m_cpm_photons);
        if(driver_settings.m_caustics_photon_map.m_op != DriverSettings::LOAD_PM) {
            cout << " ("
                << Percentage(statistics.m_cpm_photons, scene_settings.m_rendering.m_components.m_caustics.m_photon_tracing.m_photons)
                << ')';
        }
        cout << endl;

        if(driver_settings.m_caustics_photon_map.m_op == DriverSettings::BUILD_AND_SAVE_PM) {
            // Save the caustics photon map to disk.

            ss.str("");
            ss << "     * Writing CPM to file "
                << driver_settings.m_caustics_photon_map.m_file;
            progmon.Reset(ss.str());

            if(!caustics_pm->WriteToFile(
                driver_settings.m_caustics_photon_map.m_file,
                &progmon))
            {
                cerr << Error << "Failed to write to file '"
                    << driver_settings.m_caustics_photon_map.m_file << "'." << endl;
                //return EXIT_FAILURE;
            }
        }

        // Assign the caustics photon map to the scene.
        renderer.SetCausticsPhotonMap(caustics_pm);
    }

    if(driver_settings.m_primary_output.m_enabled) {
        cout << ++current_task << '/' << task_count << ". Generating primary output" << endl;

        ss.str("");
        ss << "     * Rendering";
        progmon.Reset(ss.str());
        progmon.StartJob(0.0, 1.0);

        // Initialize the renderer.
        renderer.Restart(context);

#ifdef ENABLE_MULTITHREADING
        boost::thread_group threads;

        // Create a thread that will display total rendering progress.
        threads.create_thread(ProgressMonitoringThread());
#endif  // ENABLE_MULTITHREADING

        // Render loop.
        while(!renderer.IsRenderComplete()) {
            renderer.RenderNextPixel(context);

#ifdef ENABLE_MULTITHREADING
            boost::mutex::scoped_lock lock(io_mutex);
#endif  // ENABLE_MULTITHREADING

            progmon.SetJobProgress(renderer.GetProgress());
        }

#ifdef ENABLE_MULTITHREADING
        threads.join_all();
#endif  // ENABLE_MULTITHREADING

        progmon.Done();

//framebuffer->Normalize();

//      renderer.Annotate(context);

        // Gamma correct the image if gamma correction is enabled.
        if(scene_settings.m_output.m_gamma_correction.m_enabled) {
            cout << "     * Applying gamma correction" << flush;
            framebuffer->CorrectGamma(
                scene_settings.m_output.m_gamma_correction.m_target_gamma
            );
            cout << '.' << endl;
        }

        // Write rendered image to disk.
        cout << "     * Writing rendered image to file "
            << driver_settings.m_primary_output.m_file << flush;
        if(!framebuffer->WriteToDisk(driver_settings.m_primary_output.m_file)) {
            cerr << Error << "Failed to write to file '"
                << driver_settings.m_primary_output.m_file << "'." << endl;
            //!\todo Try to save to another file (like backup.png).
            return EXIT_FAILURE;
        }
        cout << '.' << endl;
    }

    cout << endl;

    // Print statistics.
    print_statistics(statistics);

    delete caustics_pm;
    delete global_pm;
    delete camera;
    delete scene;
    delete scene_builder;
    delete framebuffer;

    return EXIT_SUCCESS;
}

---