scenesettingswrapper.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 "scenesettingswrapper.h"   // include first
#include "common/misc/stringutils.h"
#include "common/misc/xmlconfigfile.h"
#include "error.h"
#include "helpers.h"

#include <cassert>
#include <cstdlib>

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

namespace {
    void LoadSamplingSettings(const XMLConfigFile &f,
                              const string &prefix,
                              Settings::SamplingSettings *ss)
    {
        if(f.Count(prefix + "/RandomSampling") > 0) {
            ss->m_algorithm = Settings::SamplingSettings::RANDOM_SAMPLING;
            ss->m_random_sampling.m_samples = f.GetValue<int>(prefix + "/RandomSampling/@samples");
        } else if(f.Count(prefix + "/RegularSampling") > 0) {
            ss->m_algorithm = Settings::SamplingSettings::REGULAR_SAMPLING;
            ss->m_regular_sampling.m_width = f.GetValue<int>(prefix + "/RegularSampling/@width");
            ss->m_regular_sampling.m_height = f.GetValue<int>(prefix + "/RegularSampling/@height");
        } else if(f.Count(prefix + "/StratifiedSampling") > 0) {
            ss->m_algorithm = Settings::SamplingSettings::STRATIFIED_SAMPLING;
            ss->m_stratified_sampling.m_width = f.GetValue<int>(prefix + "/StratifiedSampling/@width");
            ss->m_stratified_sampling.m_height = f.GetValue<int>(prefix + "/StratifiedSampling/@height");
        } else {
            assert(!"Internal failure.");
        }
    }
}

void SceneSettingsWrapper::Load(const string &filename, const string &home_path) {
    try {
        XMLConfigFile f(filename, home_path + "schemas/toxicscene.settings.xsd");
        PrefixStack prefix("/ToxicSceneSettings");

        // <Rendering>
        prefix.Push("/Rendering");

        // <Rendering> <PixelSampling>
        prefix.Push("/PixelSampling");

        if(f.Count(prefix() + "/Supersampling") > 0) {
            // <Rendering> <PixelSampling> <Supersampling>
            prefix.Push("/Supersampling");
            m_rendering.m_pixel_sampling.m_algorithm = Rendering::PixelSampling::SUPERSAMPLING;
            LoadSamplingSettings(f, prefix(), &m_rendering.m_pixel_sampling.m_supersampling);
            prefix.Pop();
        } else {
            // <Rendering> <PixelSampling> <WhittedAdaptiveSampling>
            prefix.Push("/WhittedAdaptiveSampling");
            m_rendering.m_pixel_sampling.m_algorithm = Rendering::PixelSampling::WHITTED_ADAPTIVE_SAMPLING;
            m_rendering.m_pixel_sampling.m_whitted_adaptive_sampling.m_contrast_threshold = f.GetValue<Real>(prefix() + "/@contrastthreshold");
            m_rendering.m_pixel_sampling.m_whitted_adaptive_sampling.m_max_depth = f.GetValue<int>(prefix() + "/@maxdepth");
            prefix.Pop();
        }

        prefix.Pop();

        // <Rendering> <Components>
        prefix.Push("/Components");

        if(f.Count(prefix() + "/DirectLighting") > 0) {
            // <Rendering> <Components> <DirectLighting>
            prefix.Push("/DirectLighting");
            m_rendering.m_components.m_direct_lighting.m_enabled = true;

            // <Rendering> <Components> <DirectLighting> <ArealightSampling>
            prefix.Push("/ArealightSampling");
            LoadSamplingSettings(f, prefix(), &m_rendering.m_components.m_direct_lighting.m_arealight_sampling);
            prefix.Pop();

            prefix.Pop();
        } else m_rendering.m_components.m_direct_lighting.m_enabled = false;

        if(f.Count(prefix() + "/IndirectLighting") > 0) {
            // <Rendering> <Components> <IndirectLighting>
            prefix.Push("/IndirectLighting");
            m_rendering.m_components.m_indirect_lighting.m_enabled = true;

            // <Rendering> <Components> <IndirectLighting> <PhotonTracing>
            prefix.Push("/PhotonTracing");
            m_rendering.m_components.m_indirect_lighting.m_photon_tracing.m_photons = f.GetValue<int>(prefix() + "/@photons");
            prefix.Pop();

            if(f.Count(prefix() + "/RadiancePrecomputation") > 0) {
                // <Rendering> <Components> <IndirectLighting> <RadiancePrecomputation>
                prefix.Push("/RadiancePrecomputation");
                m_rendering.m_components.m_indirect_lighting.m_radiance_precomp.m_enabled = true;
                m_rendering.m_components.m_indirect_lighting.m_radiance_precomp.m_spacing = f.GetValue<int>(prefix() + "/@spacing");
                m_rendering.m_components.m_indirect_lighting.m_radiance_precomp.m_max_search_dist = f.GetValue<Real>(prefix() + "/@maxsearchdistance");
                prefix.Pop();
            } else m_rendering.m_components.m_indirect_lighting.m_radiance_precomp.m_enabled = false;

            // <Rendering> <Components> <IndirectLighting> <RadianceEstimate>
            prefix.Push("/RadianceEstimate");
            m_rendering.m_components.m_indirect_lighting.m_radiance_est.m_max_photons = f.GetValue<int>(prefix() + "/@maxphotons");
            m_rendering.m_components.m_indirect_lighting.m_radiance_est.m_max_distance = f.GetValue<Real>(prefix() + "/@maxdistance");
            prefix.Pop();

            if(f.Count(prefix() + "/PrimaryFinalGathering") > 0) {
                // <Rendering> <Components> <IndirectLighting> <PrimaryFinalGathering>
                prefix.Push("/PrimaryFinalGathering");
                m_rendering.m_components.m_indirect_lighting.m_primary_fg.m_enabled = true;
                LoadSamplingSettings(f, prefix(), &m_rendering.m_components.m_indirect_lighting.m_primary_fg);
                prefix.Pop();
            } else m_rendering.m_components.m_indirect_lighting.m_primary_fg.m_enabled = false;

            if(f.Count(prefix() + "/SecondaryFinalGathering") > 0) {
                // <Rendering> <Components> <IndirectLighting> <SecondaryFinalGathering>
                prefix.Push("/SecondaryFinalGathering");
                m_rendering.m_components.m_indirect_lighting.m_secondary_fg.m_enabled = true;
                m_rendering.m_components.m_indirect_lighting.m_secondary_fg.m_distance_threshold = f.GetValue<Real>(prefix() + "/@distancethreshold");
                LoadSamplingSettings(f, prefix(), &m_rendering.m_components.m_indirect_lighting.m_secondary_fg);
                prefix.Pop();
            } else m_rendering.m_components.m_indirect_lighting.m_secondary_fg.m_enabled = false;

            prefix.Pop();
        } else m_rendering.m_components.m_indirect_lighting.m_enabled = false;

        if(f.Count(prefix() + "/SpecularReflections") > 0) {
            // <Rendering> <Components> <SpecularReflections>
            prefix.Push("/SpecularReflections");
            m_rendering.m_components.m_specular_reflections.m_enabled = true;
            m_rendering.m_components.m_specular_reflections.m_max_depth = f.GetValue<int>(prefix() + "/@maxdepth");
            prefix.Pop();
        } else m_rendering.m_components.m_specular_reflections.m_enabled = false;

        if(f.Count(prefix() + "/Caustics") > 0) {
            // <Rendering> <Components> <Caustics>
            prefix.Push("/Caustics");
            m_rendering.m_components.m_caustics.m_enabled = true;

            // <Rendering> <Components> <Caustics> <PhotonTracing>
            prefix.Push("/PhotonTracing");
            m_rendering.m_components.m_caustics.m_photon_tracing.m_photons = f.GetValue<int>(prefix() + "/@photons");
            prefix.Pop();

            // <Rendering> <Components> <Caustics> <RadianceEstimate>
            prefix.Push("/RadianceEstimate");
            m_rendering.m_components.m_caustics.m_radiance_est.m_max_photons = f.GetValue<int>(prefix() + "/@maxphotons");
            m_rendering.m_components.m_caustics.m_radiance_est.m_max_distance = f.GetValue<Real>(prefix() + "/@maxdistance");
            prefix.Pop();

            prefix.Pop();
        } else m_rendering.m_components.m_caustics.m_enabled = false;

        prefix.Pop();   // <Components>

        prefix.Pop();   // <Rendering>

        // <Output>
        prefix.Push("/Output");

        if(f.Count(prefix() + "/RenderArea") > 0) {
            // <Output> <RenderArea>
            prefix.Push("/RenderArea");
            m_output.m_render_area.m_enabled = true;
            m_output.m_render_area.m_x0 = f.GetValue<int>(prefix() + "/@x0");
            m_output.m_render_area.m_y0 = f.GetValue<int>(prefix() + "/@y0");
            m_output.m_render_area.m_x1 = f.GetValue<int>(prefix() + "/@x1");
            m_output.m_render_area.m_y1 = f.GetValue<int>(prefix() + "/@y1");
            prefix.Pop();
        } else m_output.m_render_area.m_enabled = false;

        if(f.Count(prefix() + "/GammaCorrection") > 0) {
            // <Output> <GammaCorrection>
            prefix.Push("/GammaCorrection");
            m_output.m_gamma_correction.m_enabled = true;
            m_output.m_gamma_correction.m_target_gamma = f.GetValue<Real>(prefix() + "/@targetgamma");
            prefix.Pop();
        } else m_output.m_gamma_correction.m_enabled = false;

        prefix.Pop();   // <Output>

        return;
    }
    catch(const XMLConfigFile::LoadErrorException &e) {
        cerr << Error << e.m_message << endl;
    }
    catch(...) {}

    cerr << Error << "Could not load the settings file '" << filename << "'." << endl;
    exit(EXIT_FAILURE);
}

void SceneSettingsWrapper::CheckConsistency() const {
    if(!IsConsistent()) {
        cerr << Error << "Scene settings are not valid." << endl;
        exit(EXIT_FAILURE);
    }
}

namespace {
    string GetSamplingAlgorithmName(const Settings::SamplingSettings *ss) {
        switch(ss->m_algorithm) {
        case Settings::SamplingSettings::RANDOM_SAMPLING:
            return "random sampling";
        case Settings::SamplingSettings::REGULAR_SAMPLING:
            return "regular sampling";
        case Settings::SamplingSettings::STRATIFIED_SAMPLING:
            return "stratified sampling";
        default:
            assert(!"Internal failure.");
            return "<Internal failure>";    // keep the compiler happy
        }
    }

    void PrintSamplingSettings(ostream &s,
                               Indenter &indenter,
                               const Settings::SamplingSettings *ss)
    {
        indenter.Indent();

        s << indenter() << "Algorithm: "
            << GetSamplingAlgorithmName(ss)
            << endl;

        s << indenter();

        switch(ss->m_algorithm) {
        case Settings::SamplingSettings::RANDOM_SAMPLING:
            s << "Samples: "
                << ConvertNumberToString(ss->m_random_sampling.m_samples);
            break;
        case Settings::SamplingSettings::REGULAR_SAMPLING:
            {
                const int w = ss->m_regular_sampling.m_width;
                const int h = ss->m_regular_sampling.m_height;
                s << "Grid: "
                    << ConvertNumberToString(w) << "x" << ConvertNumberToString(h)
                    << " (" << ConvertNumberToString(w * h) << " samples)";
            }
            break;
        case Settings::SamplingSettings::STRATIFIED_SAMPLING:
            {
                const int w = ss->m_stratified_sampling.m_width;
                const int h = ss->m_stratified_sampling.m_height;
                s << "Grid: "
                    << ConvertNumberToString(w) << "x" << ConvertNumberToString(h)
                    << " (" << ConvertNumberToString(w * h) << " samples)";
            }
            break;
        }

        s << endl;

        indenter.Unindent();
    }
}

void SceneSettingsWrapper::Print(ostream &s) const {
    Indenter indenter;

    s << indenter() << "Scene Settings:" << endl;
    indenter.Indent();

    // <Rendering>
    s << indenter() << "Rendering" << endl;
    indenter.Indent();

    // <Rendering> <PixelSampling>
    s << indenter() << "Pixel Sampling" << endl;
    switch(m_rendering.m_pixel_sampling.m_algorithm) {
    case Rendering::PixelSampling::SUPERSAMPLING:
        // <Rendering> <PixelSampling> <Supersampling>
        PrintSamplingSettings(
            s,
            indenter,
            &m_rendering.m_pixel_sampling.m_supersampling
        );
        break;
    case Rendering::PixelSampling::WHITTED_ADAPTIVE_SAMPLING:
        // <Rendering> <PixelSampling> <WhittedAdaptiveSampling>
        indenter.Indent();
        s << indenter() << "Algorithm: Whitted adaptive sampling" << endl;
        s << indenter() << "Contrast Threshold: "
            << m_rendering.m_pixel_sampling.m_whitted_adaptive_sampling.m_contrast_threshold
            << endl;
        s << indenter() << "Maximum Depth: "
            << ConvertNumberToString(m_rendering.m_pixel_sampling.m_whitted_adaptive_sampling.m_max_depth)
            << endl;
        indenter.Unindent();
    }

    // <Rendering> <Components>
    s << indenter() << "Components" << endl;
    indenter.Indent();

    if(m_rendering.m_components.m_direct_lighting.m_enabled) {
        // <Rendering> <Components> <DirectLighting>
        s << indenter() << "+ Direct Lighting" << endl;
        indenter.Indent(4);

        // <Rendering> <Components> <DirectLighting> <ArealightSampling>
        s << indenter() << "Arealight Sampling" << endl;
        PrintSamplingSettings(
            s,
            indenter,
            &m_rendering.m_components.m_direct_lighting.m_arealight_sampling
        );

        indenter.Unindent();
    }

    if(m_rendering.m_components.m_indirect_lighting.m_enabled) {
        // <Rendering> <Components> <IndirectLighting>
        s << indenter() << "+ Indirect Lighting" << endl;
        indenter.Indent(4);

        // <Rendering> <Components> <IndirectLighting> <PhotonTracing>
        s << indenter() << "Photon Tracing" << endl;
        indenter.Indent();
        s << indenter() << "Photons: "
            << ConvertNumberToString(m_rendering.m_components.m_indirect_lighting.m_photon_tracing.m_photons)
            << endl;
        indenter.Unindent();

        if(m_rendering.m_components.m_indirect_lighting.m_radiance_precomp.m_enabled) {
            // <Rendering> <Components> <IndirectLighting> <RadiancePrecomputation>
            s << indenter() << "Radiance Precomputation" << endl;
            indenter.Indent();
            s << indenter() << "Spacing: "
                << ConvertNumberToString(m_rendering.m_components.m_indirect_lighting.m_radiance_precomp.m_spacing)
                << endl;
            s << indenter() << "Maximum Search Distance: "
                << m_rendering.m_components.m_indirect_lighting.m_radiance_precomp.m_max_search_dist
                << endl;
            indenter.Unindent();
        }

        // <Rendering> <Components> <IndirectLighting> <RadianceEstimate>
        s << indenter() << "Radiance Estimate" << endl;
        indenter.Indent();
        s << indenter() << "Maximum Photons: "
            << ConvertNumberToString(m_rendering.m_components.m_indirect_lighting.m_radiance_est.m_max_photons)
            << endl;
        s << indenter() << "Maximum Distance: "
            << m_rendering.m_components.m_indirect_lighting.m_radiance_est.m_max_distance
            << endl;
        indenter.Unindent();

        if(m_rendering.m_components.m_indirect_lighting.m_primary_fg.m_enabled) {
            // <Rendering> <Components> <IndirectLighting> <PrimaryFinalGathering>
            s << indenter() << "Primary Final Gathering" << endl;
            PrintSamplingSettings(
                s,
                indenter,
                &m_rendering.m_components.m_indirect_lighting.m_primary_fg
            );
        }

        if(m_rendering.m_components.m_indirect_lighting.m_secondary_fg.m_enabled) {
            // <Rendering> <Components> <IndirectLighting> <SecondaryFinalGathering>
            s << indenter() << "Secondary Final Gathering" << endl;
            indenter.Indent();
            s << indenter() << "Distance Threshold: "
                << m_rendering.m_components.m_indirect_lighting.m_secondary_fg.m_distance_threshold
                << endl;
            indenter.Unindent();
            PrintSamplingSettings(
                s,
                indenter,
                &m_rendering.m_components.m_indirect_lighting.m_secondary_fg
            );
        }

        indenter.Unindent();
    }

    if(m_rendering.m_components.m_specular_reflections.m_enabled) {
        // <Rendering> <Components> <SpecularReflections>
        s << indenter() << "+ Specular Reflections" << endl;
        indenter.Indent(4);
        s << indenter() << "Maximum Depth: "
            << ConvertNumberToString(m_rendering.m_components.m_specular_reflections.m_max_depth)
            << endl;
        indenter.Unindent();
    }

    if(m_rendering.m_components.m_caustics.m_enabled) {
        // <Rendering> <Components> <Caustics>
        s << indenter() << "+ Caustics" << endl;
        indenter.Indent(4);

        // <Rendering> <Components> <Caustics> <PhotonTracing>
        s << indenter() << "Photon Tracing" << endl;
        indenter.Indent();
        s << indenter() << "Photons: "
            << ConvertNumberToString(m_rendering.m_components.m_caustics.m_photon_tracing.m_photons)
            << endl;
        indenter.Unindent();

        // <Rendering> <Components> <Caustics> <RadianceEstimate>
        s << indenter() << "Radiance Estimate" << endl;
        indenter.Indent();
        s << indenter() << "Maximum Photons: "
            << ConvertNumberToString(m_rendering.m_components.m_caustics.m_radiance_est.m_max_photons)
            << endl;
        s << indenter() << "Maximum Distance: "
            << m_rendering.m_components.m_caustics.m_radiance_est.m_max_distance
            << endl;
        indenter.Unindent();

        indenter.Unindent();
    }

    indenter.Unindent();

    indenter.Unindent();

    // <Output>
    s << indenter() << "Output" << endl;
    indenter.Indent();

    if(m_output.m_render_area.m_enabled) {
        // <Output> <RenderArea>
        s << indenter() << "Render Area: ("
            << m_output.m_render_area.m_x0 << ','
            << m_output.m_render_area.m_y0 << ") to ("
            << m_output.m_render_area.m_x1 << ','
            << m_output.m_render_area.m_y1 << ')'
            << endl;
    }

    if(m_output.m_gamma_correction.m_enabled) {
        // <Output> <GammaCorrection>
        s << indenter() << "Gamma Correction: "
            << m_output.m_gamma_correction.m_target_gamma
            << endl;
    }

    indenter.Unindent();
}

---