clparser.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
*/

#include "clparser.h"   // include first
#include "common/misc/stringutils.h"
#include "driversettings.h"
#include "error.h"

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

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

CLParser::CLParser(DriverSettings *driver_settings) :
    m_driver_settings(driver_settings)
{
    assert(m_driver_settings);

    EnableFilenameExtraction(1, &CLParser::filename_handler);

    // -----------------------------------------------------------------------
    //  Primary output settings.
    // -----------------------------------------------------------------------

    RegisterOption("--output", "-o", &CLParser::opt_output);
    RegisterOption("--width", "-w", &CLParser::opt_width);
    RegisterOption("--height", "-h", &CLParser::opt_height);

    // -----------------------------------------------------------------------
    //  Photon maps settings.
    // -----------------------------------------------------------------------

    RegisterOption("--load-gpm", "", &CLParser::opt_load_gpm);
    RegisterOption("--save-gpm", "", &CLParser::opt_save_gpm);
    RegisterOption("--load-cpm", "", &CLParser::opt_load_cpm);
    RegisterOption("--save-cpm", "", &CLParser::opt_save_cpm);

    // -----------------------------------------------------------------------
    //  Miscellaneous settings.
    // -----------------------------------------------------------------------

    RegisterOption("--driver-settings", "-ds", &CLParser::opt_driver_settings);
    RegisterOption("--scene-settings", "-ss", &CLParser::opt_scene_settings);
    RegisterOption("--skip-render", "", &CLParser::opt_skip_render);
    RegisterOption("--help", "", &CLParser::opt_help);
}

void CLParser::Parse(int argc, char **argv) {
    m_progname = argv[0];

    if(argc < 2) {
        print_usage();
        exit(EXIT_FAILURE);
    }

    try {
        CommandLineParser<CLParser>::Parse(argc, argv);
        return;
    }
    catch(const UnknownOptionException &e) {
        cerr << Error << "\"" << e.m_option << "\" is not a valid option." << endl;
    }
    catch(const InvalidArgumentException &e) {
        cerr << Error << "\"" << e.m_arg << "\" is not a valid argument for option \""
            << e.m_option << "\"." << endl;
    }
    catch(const MissingArgumentException &e) {
        cerr << Error << "Missing argument for option \"" << e.m_option << "\"." << endl;
    }
    catch(const ParseException &) {
        cerr << Error << "An unknown error occured while parsing the command line." << endl;
    }

    cerr << "Please run toxic without argument to display a help message." << endl;

    exit(EXIT_FAILURE);
}

void CLParser::print_usage() const {
    cerr << "Usage: " << endl;
    cerr << "  " << m_progname << " <filename> [options]" << endl << endl;
    cerr << "Examples: " << endl;
    cerr << "  " << m_progname << " bunny.xml" << endl;
    cerr << "  " << m_progname << " bunny.xml --output bunny.png --width 720 --height 576" << endl;
    cerr << "  " << m_progname << " bunny.xml -o bunny.png -w 720 -h 576" << endl << endl;
    cerr << "Options: " << endl;
    cerr << "  Output settings" << endl;
    cerr << "    --output <filename> or -o <filename>: specify output file name." << endl;
    cerr << "        By default, output is written to ./out.png" << endl;
    cerr << "    --width <value> or -w <value>: specify output width" << endl;
    cerr << "    --height <value> or -h <value>: specify output height" << endl;
    cerr << "  Global Photon Map (GPM) settings" << endl;
    cerr << "    --load-gpm <filename>: read the GPM from disk" << endl;
    cerr << "    --save-gpm <filename>: write the GPM to disk" << endl;
    cerr << "  Caustics Photon Map (CPM) settings" << endl;
    cerr << "    --load-cpm <filename>: read the CPM from disk" << endl;
    cerr << "    --save-cpm <filename>: write the CPM to disk" << endl;
    cerr << "  Miscellaneous settings" << endl;
    cerr << "    --driver-settings <filename> or -ds <filename>: specify driver settings file name." << endl;
    cerr << "        By default, driver settings are read from {TOXICHOME}/settings/toxicsettings.xml" << endl;
    cerr << "    --scene-settings <filename> or -ss <filename>: specify scene settings file name." << endl;
    cerr << "        By default, settings for scene bunny.xml are read from ./bunny.settings.xml" << endl;
    cerr << "    --skip-render: skip the rendering part (do not produce an image)" << endl;
    cerr << "    --help: display this help message and exit" << endl;
}

void CLParser::filename_handler(const string &filename) {
    m_driver_settings->m_input_files.m_scene_file = filename;
    m_driver_settings->m_settings_files.m_scene_settings_file =
        StringUtils::RemoveExtension(filename) + ".settings.xml";
}

void CLParser::opt_output(const string &filename) {
    m_driver_settings->m_primary_output.m_file = filename;
}

void CLParser::opt_width(int width) {
    if(width < 1) {
        throw InvalidArgumentException(
            GetCurrentOptionName(),
            StringUtils::ToString(width)
        );
    }

    m_driver_settings->m_primary_output.m_width = width;
}

void CLParser::opt_height(int height) {
    if(height < 1) {
        throw InvalidArgumentException(
            GetCurrentOptionName(),
            StringUtils::ToString(height)
        );
    }

    m_driver_settings->m_primary_output.m_height = height;
}

void CLParser::opt_save_gpm(const string &filename) {
    m_driver_settings->m_global_photon_map.m_op =
        DriverSettings::BUILD_AND_SAVE_PM;
    m_driver_settings->m_global_photon_map.m_file = filename;
}

void CLParser::opt_load_gpm(const string &filename) {
    m_driver_settings->m_global_photon_map.m_op =
        DriverSettings::LOAD_PM;
    m_driver_settings->m_global_photon_map.m_file = filename;
}

void CLParser::opt_save_cpm(const string &filename) {
    m_driver_settings->m_caustics_photon_map.m_op =
        DriverSettings::BUILD_AND_SAVE_PM;
    m_driver_settings->m_caustics_photon_map.m_file = filename;
}

void CLParser::opt_load_cpm(const string &filename) {
    m_driver_settings->m_caustics_photon_map.m_op =
        DriverSettings::LOAD_PM;
    m_driver_settings->m_caustics_photon_map.m_file = filename;
}

void CLParser::opt_driver_settings(const string &filename) {
    m_driver_settings->m_settings_files.m_driver_settings_file = filename;
}

void CLParser::opt_scene_settings(const string &filename) {
    m_driver_settings->m_settings_files.m_scene_settings_file = filename;
}

void CLParser::opt_skip_render() {
    m_driver_settings->m_primary_output.m_enabled = false;
}

void CLParser::opt_help() {
    print_usage();
    exit(EXIT_SUCCESS);
}

---