settings.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 "settings.h"   // include first

using namespace sheep;
using namespace toxic;

bool Settings::SamplingSettings::RandomSampling::IsConsistent() const {
    return m_samples > 0;
}

bool Settings::SamplingSettings::RegularSampling::IsConsistent() const {
    return m_width > 0 && m_height > 0;
}

bool Settings::SamplingSettings::StratifiedSampling::IsConsistent() const {
    return m_width > 0 && m_height > 0;
}

bool Settings::SamplingSettings::IsConsistent() const {
    switch(m_algorithm) {
    case RANDOM_SAMPLING:
        return m_random_sampling.IsConsistent();
    case REGULAR_SAMPLING:
        return m_regular_sampling.IsConsistent();
    case STRATIFIED_SAMPLING:
        return m_stratified_sampling.IsConsistent();
    default:
        return false;   // keep the compiler happy
    }
}

bool Settings::RadianceEstimateSettings::IsConsistent() const {
    return m_max_photons > 0 && m_max_distance > 0.0;
}

bool Settings::Rendering::PixelSampling::WhittedAdaptiveSampling::IsConsistent() const {
    return m_contrast_threshold > 0.0 && m_max_depth >= 0;
}

bool Settings::Rendering::PixelSampling::IsConsistent() const {
    switch(m_algorithm) {
    case SUPERSAMPLING:
        return m_supersampling.IsConsistent();
    case WHITTED_ADAPTIVE_SAMPLING:
        return m_whitted_adaptive_sampling.IsConsistent();
    default:
        return false;   // keep the compiler happy
    }
}

bool Settings::Rendering::Components::DirectLighting::IsConsistent() const {
    if(m_enabled)
        return m_arealight_sampling.IsConsistent();
    else return true;
}

bool Settings::Rendering::Components::IndirectLighting::PhotonTracing::IsConsistent() const {
    return m_photons > 0;
}

bool Settings::Rendering::Components::IndirectLighting::RadiancePrecomp::IsConsistent() const {
    if(m_enabled)
        return m_spacing > 0 && m_max_search_dist > 0.0;
    else return true;
}

bool Settings::Rendering::Components::IndirectLighting::PrimaryFinalGathering::IsConsistent() const {
    if(m_enabled)
        return SamplingSettings::IsConsistent();
    else return true;
}

bool Settings::Rendering::Components::IndirectLighting::SecondaryFinalGathering::IsConsistent() const {
    if(m_enabled) {
        return
            SamplingSettings::IsConsistent() &&
            m_distance_threshold > 0.0;
    } else return true;
}

bool Settings::Rendering::Components::IndirectLighting::IsConsistent() const {
    if(m_enabled) {
        return
            m_photon_tracing.IsConsistent() &&
            m_radiance_precomp.IsConsistent() &&
            m_radiance_est.IsConsistent() &&
            m_primary_fg.IsConsistent() &&
            m_secondary_fg.IsConsistent();
    } else return true;
}

bool Settings::Rendering::Components::SpecularReflections::IsConsistent() const {
    if(m_enabled)
        return m_max_depth >= 0;
    else return true;
}

bool Settings::Rendering::Components::Caustics::PhotonTracing::IsConsistent() const {
    return m_photons > 0;
}

bool Settings::Rendering::Components::Caustics::IsConsistent() const {
    if(m_enabled) {
        return
            m_photon_tracing.IsConsistent() &&
            m_radiance_est.IsConsistent();
    } else return true;
}

bool Settings::Rendering::Components::IsConsistent() const {
    return
        m_direct_lighting.IsConsistent() &&
        m_indirect_lighting.IsConsistent() &&
        m_specular_reflections.IsConsistent() &&
        m_caustics.IsConsistent();
}

bool Settings::Rendering::IsConsistent() const {
    return
        m_pixel_sampling.IsConsistent() &&
        m_components.IsConsistent();
}

bool Settings::Output::RenderArea::IsConsistent() const {
    if(m_enabled) {
        return
            m_x0 >= 0 && m_y0 >= 0 &&
            m_x1 >= 0 && m_y1 >= 0 &&
            m_x1 >= m_x0 && m_y1 >= m_y0;
    } else return true;
}

bool Settings::Output::GammaCorrection::IsConsistent() const {
    if(m_enabled)
        return m_target_gamma > 0.0;
    else return true;
}

bool Settings::Output::IsConsistent() const {
    return
        m_render_area.IsConsistent() &&
        m_gamma_correction.IsConsistent();
}

bool Settings::IsConsistent() const {
    return
        m_rendering.IsConsistent() &&
        m_output.IsConsistent();
}

---